Servir tráfico procedente de varias regiones

gcloud

• Para crear y desplegar un servicio multirregional, ejecuta el comando gcloud run deploy con la marca --regions:

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

  Haz los cambios siguientes:

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

YAML

1. Crea el archivo YAML de tu servicio y usa el atributo run.googleapis.com/regions para definir las regiones en las que quieres desplegarlo:

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

   Haz los cambios siguientes:

   • SERVICE_NAME: nombre del servicio multirregión al que quieras implementar.
   • REGIONS: lista de las regiones que quieres actualizar. Por ejemplo, europe-west1,asia-east1.
   • IMAGE_URL: 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 run multi-region-services replace service.yaml

Terraform

Para saber cómo aplicar o quitar una configuración de Terraform, consulta Comandos básicos de Terraform.

Añade lo siguiente a un recurso google_cloud_run_v2_service en tu configuración de Terraform.

resource "google_cloud_run_v2_service" "default" {
name     = "cloudrun-service-multi-region"
regions = [
    "REGION_1",
    "REGION_2",
  ]

template {
  containers {
    image = "us-docker.pkg.dev/cloudrun/container/hello"
  }
}
}

Sustituye "REGION_1" - "REGION_2" por cada una de lasGoogle Cloud regiones que necesites. Por ejemplo, europe-west1 y us-central1.

gcloud

Para añadir o quitar regiones de un servicio multirregión, ejecuta el comando gcloud run multi-region-services update.

• Para añadir el servicio multirregión a otra u otras regiones, usa la marca --add-regions:

  gcloud 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 run multi-region-services update SERVICE_NAME \
    --remove-regions=REGIONS

  Haz los cambios siguientes:

  • SERVICE_NAME: nombre del servicio multirregión que quieras actualizar.
  • REGIONS: la región o las regiones en las que quieras añadir o quitar tu servicio. Por ejemplo, us-central1,asia-east1.

YAML

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

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

2. Actualiza el atributo run.googleapis.com/regions para añadir o quitar la lista de regiones en las que quieras implementar el servicio:

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

   Haz los cambios siguientes:

   • SERVICE_NAME: nombre del servicio multirregión al que quieras implementar.
   • REGIONS: la nueva lista de varias regiones en las que quieres que se implemente la revisión del servicio.

3. Actualiza el servicio con el siguiente comando:

   gcloud run multi-region-services replace service.yaml

CLI de gcloud

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

   gcloud compute addresses create --global SERVICE_IP

   En el comando anterior, sustituye SERVICE_IP por el nombre del recurso de dirección IP (por ejemplo, myservice-ip).

   Esta dirección IP es una dirección IPv4 de difusión general global que se dirige al centro de datos o al punto de presencia de Google más cercano a tus visitantes.

2. Crea un servicio de backend.

   gcloud compute backend-services create --global BACKEND_NAME

   En el comando anterior, sustituye BACKEND_NAME por el nombre que quieras dar al servicio backend (por ejemplo, myservice-backend).

3. Crea un mapa de URLs.

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

   Sustituye URLMAP_NAME por el nombre que quieras asignar al mapa de URLs (por ejemplo, myservice-urlmap).

4. Crea un certificado TLS gestionado para tu dominio para servir tráfico HTTPS. Sustituye example.com por el nombre de tu dominio.

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

   Sustituye CERT_NAME por el nombre que quieras asignar al certificado SSL gestionado (por ejemplo, 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

   Sustituye HTTPS_PROXY_NAME por el nombre que quieras dar al proxy HTTPS de destino (por ejemplo, myservice-https).

6. Crea una regla de reenvío que conecte los recursos de red que has creado con la dirección IP.

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

   Sustituye FORWARDING_RULE_NAME por el nombre del recurso de regla de reenvío que quieras crear (por ejemplo, myservice-lb).

Terraform

En lugar de seguir los pasos descritos en esta sección, puedes usar el módulo de Terraform del balanceador de carga HTTP global.

Para saber cómo aplicar o quitar una configuración de Terraform, consulta Comandos básicos de Terraform.

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 por el valor que quieras. Esta dirección IP es una dirección IPv4 de difusión general global que se dirige al centro de datos o al punto de presencia de Google más cercano a tus 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 por el valor que quieras.

3. Configura el mapa de URLs:

   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) con el nuevo recurso de mapa de URLs (myservice-lb-urlmap). Puedes cambiar estos valores por los que quieras.

4. Crea un certificado TLS gestionado para tu dominio y así poder servir tráfico HTTPS. Sustituye example.com por el nombre de tu 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 (myservice-ssl-cert) y los recursos de asignación de URLs (myservice-lb-urlmap) creados anteriormente. Puedes cambiar estos valores por los que quieras.

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 un recurso google_compute_global_forwarding_rule con el nombre de destino myservice-https-proxy y conecta el destino del proxy HTTPS (myservice-https-proxy) y el recurso de dirección IP (myservice-service-ip) creados anteriormente. Puedes cambiar estos valores por los que quieras.

7. Aplica esta configuración:

   Para aplicar la configuración de Terraform en un proyecto, sigue los pasos que se indican en las siguientes secciones. Google Cloud

   Preparar Cloud Shell

   1. Abre Cloud Shell.

   2. Define el Google Cloud proyecto Google Cloud predeterminado en el que quieras aplicar tus configuraciones de Terraform.

      Solo tiene que ejecutar este comando una vez por proyecto y puede hacerlo en cualquier directorio.

      export GOOGLE_CLOUD_PROJECT=PROJECT_ID

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

   Preparar 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 en ese directorio. El nombre del archivo debe tener la extensión .tf. Por ejemplo, main.tf. En este tutorial, nos referiremos al archivo como main.tf.

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

   2. Si estás siguiendo un tutorial, puedes copiar el código de ejemplo de cada sección o paso.

      Copia el código de ejemplo en el archivo main.tf que acabas de crear.

      También puedes copiar el código de GitHub. Se recomienda cuando el fragmento de Terraform forma parte de una solución integral.

   3. Revisa y modifica los parámetros de ejemplo para aplicarlos a tu entorno.
   4. Guarda los cambios.
   5. Inicializa Terraform. Solo tienes que hacerlo una vez por directorio.

      terraform init

      Si quieres usar la versión más reciente del proveedor de Google, incluye la opción -upgrade:

      terraform init -upgrade

   Aplica los cambios

   1. Revisa la configuración y comprueba que los recursos que va a crear o actualizar Terraform se ajustan a tus expectativas:

      terraform plan

      Haga las correcciones necesarias en la configuración.

   2. Aplica la configuración de Terraform ejecutando el siguiente comando e introduciendo yes en la petición:

      terraform apply

      Espera hasta que Terraform muestre el mensaje "Apply complete!".

   3. Abre tu Google Cloud proyecto para ver los resultados. En la Google Cloud consola, ve a tus recursos en la interfaz de usuario para asegurarte de que Terraform los ha creado o actualizado.

CLI de gcloud

1. Crea un grupo de endpoints 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

   Haz los cambios siguientes:

   • NEG_NAME con el nombre del recurso del grupo de puntos finales de red. Por ejemplo, `myservice-neg-uscentral1`.
   • REGION con la [región][loc] en la que se ha implementado tu servicio.
   • SERVICE_NAME con el nombre de tu servicio.

2. Añade el grupo de endpoints 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 has creado en el paso anterior para la región.

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

Terraform

Para saber cómo aplicar o quitar una configuración de Terraform, consulta Comandos básicos de Terraform.

1. Configura un grupo de endpoints de red con el nombre myservice-neg para el servicio de Cloud Run de 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 adjuntar el grupo de endpoints 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,
     ]
   }

CLI de gcloud

1. Crea un mapa de URLs con una regla de redirección.

   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

   Sustituye HTTP_URLMAP_NAME por el nombre del recurso de mapa de URLs que vas a crear (por ejemplo, myservice-httpredirect).

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

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

   Sustituye HTTP_PROXY_NAME por el nombre del proxy HTTP de destino que vas a crear (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
           

   Sustituye HTTP_FORWARDING_RULE_NAME por el nombre de la nueva regla de reenvío que vas a crear (por ejemplo, myservice-httplb).

Terraform

Para saber cómo aplicar o quitar una configuración de Terraform, consulta Comandos básicos de Terraform.

1. Crea un recurso de mapa de URLs con una regla de redirección:

   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 mapa de URLs que acabas de crear (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 el mismo recurso de 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]
   }