Criar um aplicativo com recursos atuais

Neste guia de início rápido, mostramos como organizar os recursos Google Cloud em um aplicativo do App Hub registrando-os como serviços. Primeiro, você implanta componentes de exemplo, que são usados para definir um aplicativo global da Web no App Hub.

Este início rápido é destinado a usuários que querem usar a infraestrutura atual para ganhar visibilidade e controle operacional agrupando recursos do Google Cloud em aplicativos lógicos.

Antes de começar

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

  1. Escolha seu modelo de configuração de aplicativo. Este início rápido pressupõe que você tenha definido um limite de gerenciamento de aplicativos no nível da pasta e crie um aplicativo usando o projeto de gerenciamento da pasta. Para mais informações sobre essa configuração de recursos, consulte o modelo de recursos do App Hub.

  2. Anote o ID do projeto de gerenciamento para usar em todo este documento. Para mais informações, consulte Encontrar o nome, o número e o ID do projeto.

  3. Verifique se as seguintes APIs estão ativadas no projeto de gerenciamento. Ao configurar um projeto de gerenciamento, a maioria das APIs necessárias para este 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 componentes de amostra para o aplicativo

Primeiro, implante um conjunto de recursos de amostra Google Cloud que você vai usar mais tarde para definir um aplicativo global no App Hub registrando-os como componentes do aplicativo:

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 seu 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 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 seu 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 código a seguir 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 para o serviço de back-end.
    • Um proxy HTTP para receber e encaminhar solicitações usando o mapa de URL.
    • 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 para o 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 do App Hub registrando-os como os serviços do aplicativo:

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, gravidade, 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, nomeie-a como 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 de componentes do aplicativo.

    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 amostra.

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

  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 como serviços. Esta etapa vincula sua infraestrutura ao 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, é possível usar produtos Google Cloud integrados 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. Cancele o registro dos serviços.
  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