Criar um aplicativo com recursos atuais

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.

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}

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.

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

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 =