Crea una aplicación a partir de recursos existentes

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

Esta guía de inicio rápido es para los usuarios que desean utilizar su infraestructura existente para obtener visibilidad y control operativo agrupando los recursos de Google Cloud en aplicaciones lógicas.

Antes de comenzar

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

  1. Elige el modelo de configuración de tu aplicación. En este inicio rápido, se supone que definiste un límite de administración de aplicaciones a nivel de la carpeta y se crea una aplicación con el proyecto de administració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. Toma nota del ID del proyecto de administración que usarás en todo este documento. Para obtener más información, consulta Cómo encontrar el nombre, el número y el ID del proyecto.

  3. Verifica que las siguientes APIs estén habilitadas en el proyecto de administración. Cuando configuras un proyecto de administración, la mayoría de las APIs que necesitas para este 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 obligatorios

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 componentes de muestra para la aplicación

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

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

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, la criticidad, el entorno y los 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 los componentes de la aplicación.

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

  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 como servicios. En este paso, se vincula tu infraestructura con 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 productos integrados deGoogle Cloud para supervisar su estado y rendimiento:

Realiza una limpieza

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. Cancela el registro de los servicios.
  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 desaprovisionar todos los recursos que creaste.
  4. Opcional: Si creaste un proyecto nuevo para esta guía de inicio rápido, bórralo.

¿Qué sigue?