Create an application from existing resources

gcloud

1. Set the required environment variables:

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

   Replace the following:

   • PROJECT_ID: the ID of your management project.
   • REGION: your chosen region for resources, for example, us-central1.

2. Deploy a sample Cloud Run service named hello-run:

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

3. Create the global external Application Load Balancer. This process involves the following steps:

   1. Create a serverless network endpoint group (NEG) called 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}
      

      The NEG acts as a backend for the load balancer, pointing to your hello-run service.

   2. Create a backend service to manage how traffic is distributed to the NEG:

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

   3. Add the serverless NEG to the backend service:

      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. Create a URL map to route incoming requests to the backend service:

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

   5. Create an HTTP proxy to receive requests and route them using the URL map:

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

   6. Create a global forwarding rule:

      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}
      

      This forwarding rule provides a public IP address and port to handle incoming user requests and directs them to the proxy.

Terraform

1. Create a main.tf file and add the following code:

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

   Replace the following:

   • PROJECT_ID: the ID of your management project.
   • REGION: your chosen region for resources, for example, us-central1.

   This block defines the Google Cloud provider and configures a public-facing Cloud Run service using a sample hello-world container image. It also includes an IAM policy binding to allow unauthenticated invocations, making the service publicly accessible.

2. Add the following code to your main.tf file to create the global external Application Load Balancer:

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

   This block defines the following components:

   • A serverless network endpoint group (NEG), which acts as a backend for the load balancer and points to the Cloud Run service.
   • A backend service that directs traffic to the serverless NEG.
   • A URL map to route incoming requests to the backend service.
   • An HTTP proxy to receive requests and route them using the URL map.
   • A global forwarding rule, which provides a public IP address and port to handle incoming user requests and directs them to the proxy.

3. Initialize and apply the Terraform configuration:

   terraform init
   terraform apply
   

   Terraform deploys the resources to your project.

Console

1. Go to the Applications page from App Hub:

   Go to Applications

2. Click add Create application.

3. In the Application details tab, select Global as the application location.

4. Enter my-global-app for the Application name.

5. Optionally, add a display name and a description for the application.

6. Click Continue.

7. In the Application resources tab, browse through infrastructure resources and select the checkboxes of the forwarding rule and the Cloud Run service.

8. Click Continue.

9. In the Attributes and owners tab, you can add attributes for the application, such as criticality, environment, and application owners.

   You can choose to use the same attributes and owners for the resources you are registering to the application or define those later.

10. Click Create.

When the application is created, the Applications page displays its details, including the resources you registered as services.

gcloud

1. Create the application:

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