Entrega tráfico desde varias regiones

gcloud

• Para crear e implementar un servicio multirregional, ejecuta el comando gcloud beta run deploy con la marca --regions:

  gcloud beta run deploy SERVICE_NAME \
    --image=IMAGE_URL \
    --regions=REGIONS

  Reemplaza lo siguiente:

  • SERVICE_NAME: Es el nombre del servicio multirregión que deseas implementar.
  • IMAGE_URL: Es una referencia a la imagen del contenedor, por ejemplo, us-docker.pkg.dev/cloudrun/container/hello:latest.
  • REGIONS: Es la lista de varias regiones en las que deseas realizar la implementación. Por ejemplo, us-central1,asia-east1

YAML

1. Crea el archivo YAML para tu servicio con el atributo run.googleapis.com/regions para establecer las múltiples regiones en las que deseas implementar tu servicio:

   apiVersion: serving.knative.dev/v1
   kind: Service
   metadata:
     name: SERVICE_NAME
     annotations:
       run.googleapis.com/launch-stage: BETA
       run.googleapis.com/regions: REGIONS
   spec:
     template:
       spec:
         containers:
         - image: IMAGE_URL

   Reemplaza lo siguiente:

   • SERVICE_NAME: Es el nombre del servicio multirregional al que deseas implementar.
   • REGIONS: Es la lista de varias regiones que deseas actualizar. Por ejemplo, us-central1,asia-east1
   • IMAGE_URL: Es una referencia a la imagen del contenedor, por ejemplo, us-docker.pkg.dev/cloudrun/container/hello:latest.

2. Crea el servicio con el siguiente comando:

   gcloud beta run multi-region-services replace service.yaml

gcloud

Para agregar o quitar regiones de un servicio multirregional, ejecuta el comando gcloud beta run multi-region-services update.

• Para agregar el servicio multirregional a una o más regiones adicionales, usa la marca --add-regions:

  gcloud beta run multi-region-services update SERVICE_NAME \
    --add-regions=REGIONS

• Para quitar el servicio multirregional de una o varias regiones, usa la marca --remove-regions:

  gcloud beta run multi-region-services update SERVICE_NAME \
    --remove-regions=REGIONS

  Reemplaza lo siguiente:

  • SERVICE_NAME: Es el nombre del servicio multirregión que deseas actualizar.
  • REGIONS: Es la región o regiones a las que deseas agregar o quitar tu servicio. Por ejemplo, us-central1,asia-east1

YAML

1. Para actualizar un servicio multirregional existente, descarga su configuración de YAML:

   gcloud beta run multi-region-services describe SERVICE_NAME --format export > service.yaml

2. Actualiza el atributo run.googleapis.com/regions para agregar o quitar la lista de regiones en las que deseas que se implemente el servicio:

   apiVersion: serving.knative.dev/v1
   kind: Service
   metadata:
     name: SERVICE_NAME
     annotations:
       run.googleapis.com/launch-stage: BETA
       run.googleapis.com/regions: REGIONS

   Reemplaza lo siguiente:

   • SERVICE_NAME: Es el nombre del servicio multirregional al que deseas implementar.
   • REGIONS: Es la nueva lista de varias regiones en las que deseas que se implemente la revisión del servicio.

3. Actualiza el servicio con el siguiente comando:

   gcloud beta run multi-region-services replace service.yaml

gcloud CLI

1. Reserva una dirección IP estática para que no tengas que actualizar los registros DNS cuando vuelves a crear el balanceador de cargas.

   gcloud compute addresses create --global SERVICE_IP

   En el comando anterior, reemplaza SERVICE_IP por un nombre para el recurso de dirección IP (p. ej., myservice-ip).

   Esta dirección IP es una dirección IPv4 anycast global que se enruta al centro de datos de Google o al punto de presencia más cercano a los visitantes.

2. Crea un servicio de backend.

   gcloud compute backend-services create --global BACKEND_NAME

   En el comando anterior, reemplaza BACKEND_NAME por el nombre que deseas darle al servicio de backend (p. ej., myservice-backend).

3. Crea un mapa de URL.

   gcloud compute url-maps create URLMAP_NAME --default-service=BACKEND_NAME

   Reemplaza URLMAP_NAME por el nombre que deseas asignar al mapa de URL (p. ej., myservice-urlmap).

4. Crea un certificado TLS administrado para que el dominio entregue tráfico de HTTPS. Reemplaza example.com por el nombre de dominio.

   gcloud compute ssl-certificates create CERT_NAME \
     --domains=example.com

   Reemplaza CERT_NAME por el nombre que quieres que tenga el certificado SSL administrado (p. ej., myservice-cert).

5. Crea un proxy HTTPS de destino.

   gcloud compute target-https-proxies create HTTPS_PROXY_NAME \
     --ssl-certificates=CERT_NAME \
     --url-map=URLMAP_NAME

   Reemplaza HTTPS_PROXY_NAME por el nombre que deseas otorgar al proxy HTTPS de destino (p. ej., myservice-https).

6. Crea una regla de reenvío que conecte los recursos de red que creaste a la dirección IP.

   gcloud compute forwarding-rules create --global FORWARDING_RULE_NAME \
     --target-https-proxy=HTTPS_PROXY_NAME \
     --address=SERVICE_IP \
     --ports=443

   Reemplaza FORWARDING_RULE_NAME por el nombre del recurso de regla de reenvío que deseas crear (p. ej., myservice-lb).

Terraform

Como alternativa a los pasos descritos en esta sección, puedes usar el Módulo de Terraform del balanceador de cargas de HTTP global.

Agrega lo siguiente a tu archivo de Terraform (por ejemplo, main.tf):

1. Configura la dirección IP:

   resource "google_compute_global_address" "lb_default" {
     provider = google-beta
     name     = "myservice-service-ip"
   
     # Use an explicit depends_on clause to wait until API is enabled
     depends_on = [
       google_project_service.compute_api
     ]
   }
   output "load_balancer_ip_addr" {
     value = google_compute_global_address.lb_default.address
   }

   Configura el nombre del recurso de dirección IP como myservice-service-ip. Puedes cambiarlo a tu propio valor. Esta dirección IP es una dirección IPv4 anycast global que se enruta al centro de datos de Google o al punto de presencia más cercano a los visitantes.

2. Crea y configura el servicio de backend:

   resource "google_compute_backend_service" "lb_default" {
     provider              = google-beta
     name                  = "myservice-backend"
     load_balancing_scheme = "EXTERNAL_MANAGED"
   
     backend {
       group = google_compute_region_network_endpoint_group.lb_default[0].id
     }
   
     backend {
       group = google_compute_region_network_endpoint_group.lb_default[1].id
     }
   
     # Use an explicit depends_on clause to wait until API is enabled
     depends_on = [
       google_project_service.compute_api,
     ]
   }

   Este recurso configura el servicio de backend para que se llame myservice-backend. Puedes cambiarlo a tu propio valor.

3. Configura el mapa de URL:

   resource "google_compute_url_map" "lb_default" {
     provider        = google-beta
     name            = "myservice-lb-urlmap"
     default_service = google_compute_backend_service.lb_default.id
   
     path_matcher {
       name            = "allpaths"
       default_service = google_compute_backend_service.lb_default.id
       route_rules {
         priority = 1
         url_redirect {
           https_redirect         = true
           redirect_response_code = "MOVED_PERMANENTLY_DEFAULT"
         }
       }
     }
   }

   Conecta el recurso de servicio de backend (myservice-backend) al nuevo recurso de mapa de URL (myservice-lb-urlmap). Puedes cambiarlos por tus propios valores.

4. Crea un certificado TLS administrado para que el dominio entregue tráfico de HTTPS. Reemplaza example.com por tu nombre de dominio en el recurso google_compute_managed_ssl_certificate:

   resource "google_compute_managed_ssl_certificate" "lb_default" {
     provider = google-beta
     name     = "myservice-ssl-cert"
   
     managed {
       domains = ["example.com"]
     }
   }

5. Configura el proxy HTTPS:

   resource "google_compute_target_https_proxy" "lb_default" {
     provider = google-beta
     name     = "myservice-https-proxy"
     url_map  = google_compute_url_map.lb_default.id
     ssl_certificates = [
       google_compute_managed_ssl_certificate.lb_default.name
     ]
     depends_on = [
       google_compute_managed_ssl_certificate.lb_default
     ]
   }

   Crea un recurso google_compute_target_https_proxy con el nombre de destino myservice-https-proxy y conecta el certificado TLS creado previamente (myservice-ssl-cert) y los recursos de asignación de URL (myservice-lb-urlmap). Puedes cambiarlos por tus propios valores.

6. Configura la regla de reenvío:

   resource "google_compute_global_forwarding_rule" "lb_default" {
     provider              = google-beta
     name                  = "myservice-lb-fr"
     load_balancing_scheme = "EXTERNAL_MANAGED"
     target                = google_compute_target_https_proxy.lb_default.id
     ip_address            = google_compute_global_address.lb_default.id
     port_range            = "443"
     depends_on            = [google_compute_target_https_proxy.lb_default]
   }

   Crea el recurso google_compute_global_forwarding_rule con el nombre de destino myservice-https-proxy y conecta el proxy HTTPS de destino (myservice-https-proxy) y el recurso de dirección IP (myservice-service-ip) que creaste anteriormente. Puedes cambiarlos a tus propios valores.

7. Aplica esta configuración:

   Para aplicar tu configuración de Terraform en un proyecto de Google Cloud , completa los pasos de las siguientes secciones.

   Prepara Cloud Shell

   1. Inicia Cloud Shell

   2. Establece el proyecto predeterminado de Google Cloud en el que deseas aplicar tus configuraciones de Terraform.

      Solo necesitas ejecutar este comando una vez por proyecto y puedes ejecutarlo en cualquier directorio.

      export GOOGLE_CLOUD_PROJECT=PROJECT_ID

      Las variables de entorno se anulan si configuras valores explícitos en el archivo de configuración de Terraform.

   Prepara el directorio

   Cada archivo de configuración de Terraform debe tener su propio directorio (también llamado módulo raíz).

   1. En Cloud Shell, crea un directorio y un archivo nuevo dentro de ese directorio. El nombre del archivo debe tener la extensión .tf, por ejemplo, main.tf. En este instructivo, el archivo se denomina main.tf.

      mkdir DIRECTORY && cd DIRECTORY && touch main.tf

   2. Si sigues un instructivo, puedes copiar el código de muestra en cada sección o paso.

      Copia el código de muestra en el main.tf recién creado.

      De manera opcional, copia el código de GitHub. Esto se recomienda cuando el fragmento de Terraform es parte de una solución de extremo a extremo.

   3. Revisa y modifica los parámetros de muestra que se aplicarán a tu entorno.
   4. Guarda los cambios.
   5. Inicializa Terraform. Solo debes hacerlo una vez por directorio.

      terraform init

      De manera opcional, incluye la opción -upgrade para usar la última versión del proveedor de Google:

      terraform init -upgrade

   Aplica los cambios

   1. Revisa la configuración y verifica que los recursos que creará o actualizará Terraform coincidan con tus expectativas:

      terraform plan

      Corrige la configuración según sea necesario.

   2. Para aplicar la configuración de Terraform, ejecuta el siguiente comando y, luego, escribe yes cuando se te solicite:

      terraform apply

      Espera hasta que Terraform muestre el mensaje “¡Aplicación completa!”.

   3. Abre tu proyecto de para ver los resultados. En la consola de Google Cloud , navega a tus recursos en la IU para asegurarte de que Terraform los haya creado o actualizado.

gcloud CLI

1. Crea un grupo de extremos de red para el servicio de Cloud Run en REGION:

   gcloud compute network-endpoint-groups create NEG_NAME \
     --region=REGION \
     --network-endpoint-type=SERVERLESS \
     --cloud-run-service=SERVICE_NAME

   Reemplaza lo siguiente:

   • NEG_NAME por el nombre del recurso del grupo de extremos de red (p. ej., “myservice-neg-uscentral1”)
   • REGION por la [region][loc] en la que se implementa el servicio
   • SERVICE_NAME por el nombre de tu servicio

2. Agrega el grupo de extremos de red al servicio de backend:

   gcloud compute backend-services add-backend --global BACKEND_NAME \
     --network-endpoint-group-region=REGION \
     --network-endpoint-group=NEG_NAME

   Especifica el NEG_NAME que creaste en el paso anterior para la región.

3. Repite los pasos anteriores para cada región.

Terraform

1. Configura un grupo de extremos de red con el nombre myservice-neg para el servicio de Cloud Run en cada región especificada en la variable run_regions:

   resource "google_compute_region_network_endpoint_group" "lb_default" {
     provider              = google-beta
     count                 = length(local.run_regions)
     name                  = "myservice-neg"
     network_endpoint_type = "SERVERLESS"
     region                = local.run_regions[count.index]
     cloud_run {
       service = google_cloud_run_v2_service.run_default[count.index].name
     }
   }

2. Configura un servicio de backend para conectar el grupo de extremos de red (myservice-neg):

   resource "google_compute_backend_service" "lb_default" {
     provider              = google-beta
     name                  = "myservice-backend"
     load_balancing_scheme = "EXTERNAL_MANAGED"
   
     backend {
       group = google_compute_region_network_endpoint_group.lb_default[0].id
     }
   
     backend {
       group = google_compute_region_network_endpoint_group.lb_default[1].id
     }
   
     # Use an explicit depends_on clause to wait until API is enabled
     depends_on = [
       google_project_service.compute_api,
     ]
   }

gcloud CLI

1. Cree un mapa de URL con una regla de redireccionamiento.

   gcloud compute url-maps import HTTP_URLMAP_NAME \
     --global \
     --source /dev/stdin <<EOF
           name: HTTP_URLMAP_NAME
           defaultUrlRedirect:
             redirectResponseCode: MOVED_PERMANENTLY_DEFAULT
             httpsRedirect: True
           EOF

   Reemplaza HTTP_URLMAP_NAME por el nombre del recurso de mapa de URL que crearás (por ejemplo, myservice-httpredirect).

2. Crea un proxy HTTP de destino con el mapa de URL.

   gcloud compute target-http-proxies create HTTP_PROXY_NAME \
     --url-map=HTTP_URLMAP_NAME

   Reemplaza HTTP_PROXY_NAME por el nombre del proxy HTTP de destino que crearás (por ejemplo, myservice-http).

3. Crea una regla de reenvío en el puerto 80 con la misma dirección IP reservada.

   gcloud compute forwarding-rules create --global HTTP_FORWARDING_RULE_NAME \
     --target-http-proxy=HTTP_PROXY_NAME \
     --address=SERVICE_IP \
     --ports=80
           

   Reemplaza HTTP_FORWARDING_RULE_NAME por el nombre de la regla de reenvío nueva que crearás (por ejemplo, myservice-httplb).

Terraform

1. Cree un recurso de mapa de URL con una regla de redireccionamiento.

   resource "google_compute_url_map" "https_default" {
     provider = google-beta
     name     = "myservice-https-urlmap"
   
     default_url_redirect {
       redirect_response_code = "MOVED_PERMANENTLY_DEFAULT"
       https_redirect         = true
       strip_query            = false
     }
   }

2. Crea un proxy HTTP de destino con el recurso de asignación de URL recién creado (myservice-https-urlmap):

   resource "google_compute_target_http_proxy" "https_default" {
     provider = google-beta
     name     = "myservice-http-proxy"
     url_map  = google_compute_url_map.https_default.id
   
     depends_on = [
       google_compute_url_map.https_default
     ]
   }

3. Crea una regla de reenvío en el puerto 80 con la misma dirección IP reservada (myservice-http-proxy).

   resource "google_compute_global_forwarding_rule" "https_default" {
     provider   = google-beta
     name       = "myservice-https-fr"
     target     = google_compute_target_http_proxy.https_default.id
     ip_address = google_compute_global_address.lb_default.id
     port_range = "80"
     depends_on = [google_compute_target_http_proxy.https_default]
   }