Crie uma aplicação a partir de recursos existentes

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

Este início rápido destina-se a utilizadores que querem usar a respetiva infraestrutura existente para obter visibilidade e controlo operacional agrupando recursos em aplicações lógicas. Google Cloud

Antes de começar

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

  1. Escolha o modelo de configuração da aplicação. Este início rápido pressupõe que definiu um limite de gestão de aplicações ao nível da pasta e cria uma aplicação através do projeto de gestão da pasta. Para mais informações acerca desta configuração de recursos, consulte o modelo de recursos do App Hub.

  2. Tenha em atenção o ID do projeto de gestão a usar ao longo deste documento. Para mais informações, consulte o artigo Encontre o nome, o número e o ID do projeto.

  3. Confirme se as seguintes APIs estão ativadas no projeto de gestão. Quando configura um projeto de gestão, 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 componentes de exemplo 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, registando-os como componentes da aplicação: Google Cloud

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 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 encaminha-os 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 seu 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 URLs 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 do App Hub, registando-os como os serviços da aplicação:

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 de componentes da aplicação.

    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 seus 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 como serviços.

  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 recursos google_apphub_service registam formalmente os recursos descobertos na sua aplicação como serviços. Este passo associa a sua infraestrutura à 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 produtos Google Cloud 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 dos serviços.
  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?