Crie uma aplicação a partir de recursos existentes

Este início rápido mostra como organizar os serviços existentes Google Cloud numa aplicação do App Hub. Primeiro, implementa uma configuração de exemplo, que usa para definir uma aplicação Web global registando os respetivos componentes como uma aplicação no App Hub.

Esta abordagem destina-se a utilizadores que querem usar a respetiva infraestrutura existente para obter visibilidade e controlo operacional agrupando recursos em aplicações lógicas.

Antes de começar

Antes de iniciar este início rápido, faça o seguinte:

  1. Configure o App Hub com uma pasta compatível com apps.

    Google Cloud

  2. Tenha em atenção o ID do projeto de gestão a usar ao longo deste documento.

  3. Verifique se as seguintes APIs estão ativadas no projeto de gestão. Quando configura uma pasta com apps ativadas, a maioria das APIs de que precisa para este início rápido é ativada automaticamente.

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

    Ative as APIs

Funções necessárias

Para receber as autorizações de que precisa para ativar as APIs necessárias e criar uma aplicação de exemplo a partir de recursos existentes, peça ao seu administrador para lhe conceder as seguintes funções do IAM no projeto de gestão:

Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

Implemente recursos para a aplicação

Primeiro, tem de implementar um conjunto de recursos de exemplo que vai usar mais tarde para definir uma aplicação global no App Hub:

  • Um serviço do Cloud Run que funciona como o back-end da aplicação.
  • Um Application Load Balancer externo global que direciona o tráfego para o serviço do Cloud Run como uma regra de encaminhamento.

Siga estes passos para implementar estes recursos:

gcloud

  1. Defina as variáveis de ambiente necessárias:

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

    Substitua o seguinte:

    • PROJECT_ID: o ID do seu projeto de gestão.
    • REGION: a região escolhida para os recursos, por exemplo, us-central1.

  2. Implemente um serviço de exemplo do Cloud Run denominado hello-run:

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

  3. Crie o balanceador de carga de aplicações externo global. Este processo envolve os seguintes passos:

    1. Crie um grupo de pontos finais da rede (NEG) sem servidor denominado 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}

      O NEG atua como um back-end para o balanceador de carga, apontando para o seu serviço hello-run.

    2. Crie um serviço de back-end para gerir a forma como o tráfego é distribuído para o NEG:

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

    3. Adicione o NEG sem servidor como back-end ao serviço de back-end:

      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. Crie um mapa de URLs para encaminhar pedidos recebidos para o serviço de back-end:

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

    5. Crie um proxy HTTP para receber pedidos e encaminhá-los através do mapa de URLs:

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

    6. Crie uma regra de encaminhamento 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 regra de encaminhamento fornece um endereço IP público e uma porta para processar pedidos de utilizadores recebidos e encaminhá-los para o proxy.

Terraform

  1. Crie um ficheiro main.tf e adicione o seguinte 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"
}

    Substitua o seguinte:

    • PROJECT_ID: o ID do seu projeto de gestão.
    • REGION: a região escolhida para os recursos, por exemplo, us-central1.

    Este bloco define o Google Cloud fornecedor e configura um serviço do Cloud Run acessível ao público através de uma imagem de contentor de exemplohello-world. Também inclui uma associação de políticas do IAM para permitir invocações não autenticadas, tornando o serviço acessível publicamente.

  2. Adicione o seguinte código ao ficheiro main.tf para criar o Application Load Balancer 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 bloco define os seguintes componentes:

    • Um grupo de pontos finais da rede (NEG) sem servidor, que funciona como um back-end para o balanceador de carga e aponta para o serviço do Cloud Run.
    • Um serviço de back-end que direciona o tráfego para o NEG sem servidor.
    • Um mapa de URL para encaminhar pedidos recebidos para o serviço de back-end.
    • Um proxy HTTP para receber pedidos e encaminhá-los através do mapa de URLs.
    • Uma regra de encaminhamento global, que fornece um endereço IP público e uma porta para processar pedidos de utilizadores recebidos e encaminhá-los para o proxy.

  3. Inicialize e aplique a configuração do Terraform:

    terraform init
terraform apply

    O Terraform implementa os recursos no seu projeto.

Defina a aplicação no App Hub

Depois de implementar os recursos como uma regra de encaminhamento e um serviço do Cloud Run, siga estes passos para os agrupar numa aplicação no App Hub:

Consola

  1. Aceda à página Aplicações a partir do App Hub:

    Aceda a Aplicações

  2. Clique em Criar candidatura.

  3. Selecione Global como a localização da aplicação.

  4. Introduza my-global-app para o Nome da aplicação e clique em Continuar.

  5. Opcionalmente, adicione um nome a apresentar, a criticidade, o ambiente e os proprietários.

  6. Clique em Criar.

  7. No separador Serviços e cargas de trabalho, clique em Registar serviço/carga de trabalho.

  8. Selecione a regra de encaminhamento, atribua-lhe o nome frontend-service e clique em Registar.

  9. Selecione o serviço do Cloud Run, atribua-lhe o nome backend-service e clique em Registar.

gcloud

  1. Crie a aplicação:

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

  2. Descubra os IDs da regra de encaminhamento e do serviço do Cloud Run na região adequada:

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

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

    Tome nota do ID da regra de encaminhamento e do serviço do Cloud Run.

  3. Registe a regra de encaminhamento na aplicação 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}

    Substitua FRONTEND_ID pelo ID da regra de encaminhamento.

  4. Registe o serviço do Cloud Run na aplicação 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}

    Substitua BACKEND_ID pelo ID do serviço do Cloud Run.

Terraform

  1. Crie um ficheiro application.tf e adicione o seguinte 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 bloco usa o recurso google_apphub_application para criar um agrupamento lógico para os seus serviços e cargas de trabalho.

    Este exemplo cria uma aplicação global e define atributos para governança e capacidade de deteção, como criticidade, ambiente e proprietários. Pode modificar esses valores para a sua configuração de exemplo.

  2. Adicione o seguinte código a application.tf para descobrir os 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}"
}

    As origens de dados google_apphub_discovered_service encontram os nomes dos recursos da sua infraestrutura existente com base nos respetivos URIs. Este passo permite que o App Hub identifique os recursos específicos que quer registar.

  3. Adicione o seguinte código a application.tf para registar os recursos descobertos:

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

    Os google_apphub_service recursos registam formalmente os recursos descobertos na sua aplicação. Este passo cria a associação entre a sua infraestrutura e a aplicação que definiu no App Hub.

  4. Inicialize e aplique a configuração do Terraform:

    terraform init
terraform apply

    O Terraform regista os recursos na sua aplicação my-global-app no App Hub.

Opcional: monitorize a sua nova aplicação

Depois de definir a sua aplicação no App Hub, pode usar osGoogle Cloud serviços integrados para monitorizar o respetivo estado e desempenho:

Limpar

Para evitar incorrer em cobranças na sua Google Cloud conta pelos recursos usados nesta página, siga estes passos.

  1. Anule o registo de serviços e cargas de trabalho.
  2. Elimine a aplicação global.
  3. Se usou o Terraform para implementar a sua aplicação, execute terraform destroy no diretório que contém os seus ficheiros do Terraform para desaprovisionar todos os recursos que criou.
  4. Opcional: se criou um novo projeto para este início rápido, elimine o projeto.

O que se segue?