Criar um aplicativo com recursos atuais

Neste guia de início rápido, mostramos como organizar os serviços Google Cloud em um aplicativo do App Hub. Primeiro, implante uma configuração de exemplo, que será usada para definir um aplicativo da Web global registrando os componentes dele como um aplicativo no App Hub.

Essa abordagem é para usuários que querem usar a infraestrutura atual para ganhar visibilidade e controle operacional agrupando recursos em aplicativos lógicos.

Antes de começar

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

  1. Configure o App Hub com uma pasta habilitada para gerenciar apps.

  2. Anote o ID do projeto de gerenciamento para usar em todo este documento.

  3. Verifique se as seguintes APIs estão ativadas no projeto de gerenciamento. Ao configurar uma pasta compatível com apps, a maioria das APIs necessárias para este guia de início rápido é ativada automaticamente.

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

    Ativar APIs

Funções exigidas

Para receber as permissões necessárias para ativar as APIs obrigatórias e criar um aplicativo de amostra com recursos atuais, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto de gerenciamento:

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.

Implantar recursos para o aplicativo

Primeiro, implante um conjunto de recursos de amostra que você usará mais tarde para definir um aplicativo global no App Hub:

  • Um serviço do Cloud Run que atua como back-end do aplicativo.
  • Um balanceador de carga de aplicativo externo global que direciona o tráfego para o serviço do Cloud Run como uma regra de encaminhamento.

Siga estas etapas para implantar esses recursos:

gcloud

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

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

    Substitua:

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

  2. Implante um serviço de amostra do Cloud Run chamado 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 aplicativo externo global. Esse processo envolve as seguintes etapas:

    1. Crie um grupo de endpoints de rede (NEG) sem servidor chamado 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 serviço hello-run.

    2. Crie um serviço de back-end para gerenciar 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 um 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 URL para encaminhar solicitações recebidas 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 solicitações e encaminhá-las usando o 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}

      Essa regra de encaminhamento fornece um endereço IP público e uma porta para processar solicitações de usuários recebidas e as direciona ao proxy.

Terraform

  1. Crie um arquivo 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:

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

    Esse bloco define o Google Cloud provedor e configura um serviço do Cloud Run voltado ao público usando uma imagem de contêiner hello-world de amostra. Ele também inclui uma vinculação de política do IAM para permitir invocações não autenticadas, tornando o serviço acessível ao público.

  2. Adicione o seguinte código ao arquivo main.tf para criar o balanceador de carga de aplicativo 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"
}

    Esse bloco define os seguintes componentes:

    • Um grupo de endpoints de rede (NEG) sem servidor, que atua 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 solicitações recebidas ao serviço de back-end.
    • Um proxy HTTP para receber solicitações e encaminhá-las usando o mapa de URLs.
    • Uma regra de encaminhamento global, que fornece um endereço IP público e uma porta para processar solicitações de usuários recebidas e as direciona ao proxy.

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

    terraform init
terraform apply

    O Terraform implanta os recursos no seu projeto.

Definir o aplicativo no App Hub

Depois de implantar os recursos como uma regra de encaminhamento e um serviço do Cloud Run, siga estas etapas para agrupá-los em um aplicativo no App Hub:

Console

  1. Acesse a página Aplicativos no App Hub:

    Acesse Aplicativos

  2. Clique em Criar aplicativo.

  3. Selecione Global como o local do aplicativo.

  4. Insira my-global-app no Nome do aplicativo e clique em Continuar.

  5. Se quiser, adicione um nome de exibição, uma gravidade, um ambiente e proprietários.

  6. Clique em Criar.

  7. Na guia Serviços e cargas de trabalho, clique em Registrar serviço/carga de trabalho.

  8. Selecione a regra de encaminhamento, dê a ela o nome frontend-service e clique em Registrar.

  9. Selecione o serviço do Cloud Run, nomeie-o como backend-service e clique em Registrar.

gcloud

  1. Crie o aplicativo:

    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 apropriada:

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

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

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

  3. Registre a regra de encaminhamento no aplicativo 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. Registre o serviço do Cloud Run no aplicativo 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 arquivo 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"
    }
  }
}

    Esse bloco usa o recurso google_apphub_application para criar um agrupamento lógico dos seus serviços e cargas de trabalho.

    Este exemplo cria um aplicativo global e define atributos para governança e capacidade de descoberta, como criticidade, ambiente e proprietários. É possível modificar esses valores para sua configuração de exemplo.

  2. Adicione o seguinte código a application.tf para descobrir os recursos implantados:

    # 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 fontes de dados google_apphub_discovered_service encontram os nomes de recursos da sua infraestrutura atual com base nos URIs. Essa etapa permite que o App Hub identifique os recursos específicos que você quer registrar.

  3. Adicione o seguinte código a application.tf para registrar 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 registram formalmente os recursos descobertos no seu aplicativo. Esta etapa cria o link entre sua infraestrutura e o aplicativo definido no App Hub.

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

    terraform init
terraform apply

    O Terraform registra os recursos no aplicativo my-global-app no App Hub.

Opcional: monitorar seu novo aplicativo

Depois de definir seu aplicativo no App Hub, use os serviços integrados do Google Cloud para monitorar a integridade e o desempenho dele:

Limpar

Para evitar cobranças na conta do Google Cloud pelos recursos usados nesta página, siga as etapas abaixo.

  1. Cancelar o registro de serviços e cargas de trabalho.
  2. Exclua o aplicativo global.
  3. Se você usou o Terraform para implantar o aplicativo, execute terraform destroy no diretório que contém os arquivos do Terraform para desprovisionar todos os recursos criados.
  4. Opcional: se você criou um novo projeto para este guia de início rápido, exclua o projeto.

A seguir