Aprovisionar una organización de pago con emparejamiento de VPC

Esta página se aplica a Apigee, pero no a Apigee Hybrid.

Consulta la documentación de Apigee Edge.

En este documento se describe cómo instalar y configurar Apigee desde la línea de comandos con el emparejamiento de VPC. Estos pasos se aplican a los modelos de precios de suscripción y de pago por uso de las organizaciones de pago con o sin la residencia de datos habilitada.

Nota: Si tu proyecto tiene una restricción de política de organización de CMEK, no todas las funciones de Apigee utilizan CMEK para cifrar datos sensibles. Consulta la sección Usar restricciones de políticas de organización en Apigee para obtener una descripción de cómo gestiona Apigee las restricciones de políticas de organización y la sección Restricciones de políticas de organización para ver una descripción de las funciones de Apigee que cumplen los requisitos de CMEK.

Resumen de los pasos

Los pasos de aprovisionamiento son los siguientes:

• Paso 1: Define las variables de entorno: Configura gcloud y define las variables de entorno. La CLI de Google Cloud gestiona la autenticación, la configuración local, el flujo de trabajo de desarrollo y las interacciones con las APIs de Google Cloud.
• Paso 2: Habilita las APIs: Apigee requiere que habilites varias APIs de Google Cloud.
• Paso 3: Crea la identidad de servicio de Apigee: esta cuenta de servicio la usan las bibliotecas de cliente de Google Cloud para autenticarse en las APIs de Google Cloud.
• Paso 4: Configura Service Networking: Service Networking automatiza la configuración de la conectividad privada (mediante el emparejamiento entre redes de VPC) entre tu red y Apigee.
• Paso 5: Crea una organización: una organización de Apigee (a veces denominada "org") es el contenedor de nivel superior de Apigee. Incluye todos tus entornos y grupos de entornos, usuarios, proxies de API y recursos relacionados.
• Paso 6: Crea una instancia de entorno de ejecución: una instancia o un entorno de ejecución es el lugar donde se almacenan tu proyecto y los servicios relacionados. Proporciona el endpoint visible para los usuarios de tus servicios.
• Paso 7: Crea un entorno: un proxy de API debe desplegarse en un entorno y añadirse a un grupo de entornos para que las APIs que expone sean accesibles a través de la red.
• Paso 8: Configura el enrutamiento: permite el acceso externo o solo interno a tu API.
• Paso 9: Despliega un proxy de ejemplo: prueba el aprovisionamiento desplegando y llamando a un proxy de API.

Paso 1: Define las variables del entorno

Configura gcloud y define las variables de entorno que se usarán en pasos posteriores:

1. Asegúrate de que has completado los requisitos de configuración que se indican en la sección Antes de empezar.
2. Debes tener instalado el SDK de Google Cloud. Si necesitas instalarlo, consulta el artículo Instalar el SDK de Google Cloud.
3. Inicializa el SDK de Cloud, tal como se describe en Inicializar la CLI de gcloud, o asegúrate de que el proyecto de Google Cloud que has creado en Requisitos sea el proyecto predeterminado de gcloud.
4. Define las siguientes variables de entorno en el terminal de comandos. Selecciona la pestaña que corresponda al tipo de organización que necesites: Sin residencia de datos o con Residencia de datos:
   Nota: Guarda las variables de entorno en un archivo de texto para poder restaurarlas fácilmente si es necesario.

   Sin residencia de datos

   AUTH="$(gcloud auth print-access-token)"
   PROJECT_ID="YOUR_PROJECT_ID"
   PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
   RUNTIME_LOCATION="YOUR_RUNTIME_LOCATION"
   ANALYTICS_REGION="YOUR_ANALYTICS_REGION"
   BILLING_TYPE="YOUR_BILLING_TYPE"

   Nota: Si vas a aprovisionar una organización de Apigee en un proyecto Google Cloud con una restricción de ubicación de recursos aplicada en una política de organización, confirma que la restricción de ubicación esté definida como global. Como el plano de control de Apigee es una entidad global de forma predeterminada, el aprovisionamiento fallará si se aplica una restricción que no sea global. Para obtener más información, consulta el artículo Introducción a la residencia de datos.

   Donde:

   • AUTH define el encabezado Authentication con un token de portador. Usarás este encabezado al llamar a las APIs de Apigee. Ten en cuenta que el token caduca al cabo de un periodo y, cuando lo haga, puedes volver a generarlo con el mismo comando. Para obtener más información, consulta la página de referencia del comando print-access-token.
   • PROJECT_ID es el ID del proyecto de Cloud que has creado en los requisitos previos.
   • PROJECT_NUMBER es el número del proyecto de Cloud que has creado en la sección Requisitos.

   • RUNTIME_LOCATION es la ubicación física en la que se encuentra la instancia de Apigee que crearás más adelante. Para ver una lista de las ubicaciones de tiempo de ejecución disponibles, consulta Ubicaciones de Apigee.

     Nota: En el caso de RUNTIME_LOCATION, asegúrate de usar el nombre de una región y no el de una zona. Por ejemplo, us-west1 es el nombre de una región, mientras que us-west1-a es una zona de esa región. Consulta también Identificar una región o una zona.

   • ANALYTICS_REGION es la ubicación física en la que se almacenarán los datos de analíticas de Apigee. Para ver una lista de las regiones disponibles de Apigee API Analytics, consulta Ubicaciones de Apigee.

     Tanto RUNTIME_LOCATION como ANALYTICS_REGION pueden ser la misma región, pero no tienen por qué serlo.

   • BILLING_TYPE es el tipo de facturación de la organización que crees. Los valores válidos son estos:

     • PAYG para organizaciones con el modelo de Pay-as-you-go.
     • SUBSCRIPTION para organizaciones con suscripción.

   Residencia de datos

   AUTH="$(gcloud auth print-access-token)"
   PROJECT_ID="YOUR_PROJECT_ID"
   PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
   RUNTIME_LOCATION="YOUR_RUNTIME_LOCATION"
   CONTROL_PLANE_LOCATION="YOUR_CONTROL_PLANE_LOCATION"
   CONSUMER_DATA_REGION="YOUR_CONSUMER_DATA_REGION"
   BILLING_TYPE="YOUR_BILLING_TYPE"

   Importante: Cuando se usa la residencia de datos, la ubicación del plano de control es la región contenedora. Todas las demás regiones deben estar en la ubicación del plano de control. Si la ubicación del plano de control es us, la región de datos del consumidor y la ubicación del tiempo de ejecución también deben estar en us. Por ejemplo, us-west1 es aceptable, pero europe-west1 no.

   Donde:

   • AUTH define el encabezado Authentication con un token de portador. Usará este encabezado al llamar a las APIs de Apigee. Ten en cuenta que el token caduca al cabo de un periodo y, cuando lo haga, puedes volver a generarlo con el mismo comando. Para obtener más información, consulta la página de referencia del comando print-access-token.
   • PROJECT_ID es el ID del proyecto de Cloud que has creado en los requisitos.
   • PROJECT_NUMBER es el número del proyecto de Cloud que has creado en la sección Requisitos.

   • RUNTIME_LOCATION es la ubicación física en la que se encuentra la instancia de Apigee que crearás más adelante. Para ver una lista de las ubicaciones de tiempo de ejecución disponibles, consulta Ubicaciones de Apigee.

     Nota: En el caso de RUNTIME_LOCATION, asegúrate de usar el nombre de una región y no el de una zona. Por ejemplo, us-west1 es el nombre de una región, mientras que us-west1-a es una zona de esa región. Consulta también Identificar una región o una zona.
     La ubicación del tiempo de ejecución debe estar dentro de la ubicación del plano de control.
   • CONTROL_PLANE_LOCATION es la ubicación física en la que se almacenarán los datos del plano de control de Apigee. Para ver una lista de las ubicaciones del plano de control disponibles, consulta Ubicaciones de Apigee.
   • CONSUMER_DATA_REGION es una subregión de la región del plano de control. Debes especificar tanto CONTROL_PLANE_LOCATION como CONSUMER_DATA_REGION. Para ver una lista de las regiones de datos de consumidores disponibles, consulta Ubicaciones de Apigee.

   • BILLING_TYPE es el tipo de facturación de la organización que crees. Los valores válidos son estos:

     • PAYG para organizaciones con el modelo de Pay-as-you-go.
     • SUBSCRIPTION para organizaciones con suscripción.

5. (Opcional) Comprueba tu trabajo repitiendo los valores que acabas de definir. Ten en cuenta que, si quieres usar una variable en tus comandos, debes poner el signo de dólar ($) delante del nombre de la variable.

   Sin residencia de datos

   echo $AUTH
   echo $PROJECT_ID
   echo $PROJECT_NUMBER
   echo $RUNTIME_LOCATION
   echo $ANALYTICS_REGION
   echo $BILLING_TYPE
   

   Las respuestas a tus comandos echo deberían tener un aspecto similar al siguiente:

   YOUR_TOKEN
   my-cloud-project
   1234567890
   us-west1
   us-west1
   SUBSCRIPTION
   

   Residencia de datos

   echo $AUTH
   echo $PROJECT_ID
   echo $PROJECT_NUMBER
   echo $RUNTIME_LOCATION
   echo $CONTROL_PLANE_LOCATION
   echo $CONSUMER_DATA_REGION
   echo $BILLING_TYPE
   

   Las respuestas a tus comandos echo deberían tener un aspecto similar al siguiente:

   YOUR_TOKEN
   my-cloud-project
   1234567890
   us-west1
   us
   us-west1
   SUBSCRIPTION
   

Paso 2: Habilita las API

Permisos que se necesitan para completar esta tarea

Puedes asignar al aprovisionador de Apigee un rol predefinido que incluya los permisos necesarios para completar esta tarea o conceder permisos más específicos para proporcionar los privilegios mínimos necesarios. Consulta las secciones sobre roles predefinidos y permisos de habilitación de APIs.

1. Apigee requiere que habilites varias APIs de Google Cloud. Para habilitarlos, ejecuta el siguiente comando services enable:

   gcloud services enable apigee.googleapis.com \
       servicenetworking.googleapis.com \
       apihub.googleapis.com \
       compute.googleapis.com \
       cloudkms.googleapis.com --project=$PROJECT_ID

2. (Opcional) Para comprobar tu trabajo, usa el comando services list para mostrar todas las APIs habilitadas:

   gcloud services list

   En la respuesta se muestran todos los servicios habilitados, incluidas las APIs que acabas de habilitar.

Paso 3: Crea la identidad de servicio de Apigee

Advertencia: Las cuentas de servicio son cuentas especiales que necesita Apigee para aprovisionar tus instancias de tiempo de ejecución. Si eliminas cuentas de servicio, tus instancias de tiempo de ejecución no se podrán usar.

1. Crea la identidad de servicio de Apigee:

   gcloud beta services identity create --service=apigee.googleapis.com \
     --project=$PROJECT_ID

2. Comprueba que el agente se haya creado correctamente. En la respuesta se debe mostrar el nombre del agente con el siguiente formato: [e-mail]. por ejemplo:

   Service identity created: [e-mail]

Paso 4: Configura las redes de servicios

En este paso, asignas un par de intervalos de direcciones IP (un intervalo CIDR /22 y otro /28) a Apigee y realizas el emparejamiento de VPC entre tu red y la de Apigee. Cada instancia de Apigee requiere un intervalo CIDR de /22 y /28 que no se solape. Al plano de ejecución de Apigee se le asignan direcciones IP de este intervalo CIDR. Por lo tanto, es importante que el intervalo se reserve para Apigee y que no lo utilicen otras aplicaciones de tu red de VPC. Para obtener más información y consideraciones importantes, consulta Información sobre los intervalos de emparejamiento.

Ten en cuenta que estás creando un intervalo de IP de red suficiente para una instancia de Apigee. Si tienes previsto crear instancias de Apigee adicionales, debes repetir este paso con cada una de ellas. Los intervalos no se pueden compartir entre instancias. Consulta también Ampliar Apigee a varias regiones.

Importante: Si ya tienes un intervalo de emparejamiento y una conexión privada con servicenetworking.googleapis.com y tu intervalo es lo suficientemente grande como para gestionar otro intervalo CIDR de /22 y /28, puedes saltarte este paso. Apigee creará los bloques CIDR necesarios. Este paso solo es necesario si aún no has creado un espacio que tenga sitio para crear un bloque /22 y /28, o si quieres usar un bloque /22 y /28 específico que no esté presente.

Permisos necesarios para esta tarea

Puedes asignar al aprovisionador de Apigee un rol predefinido que incluya los permisos necesarios para completar esta tarea o conceder permisos más específicos para proporcionar los privilegios mínimos necesarios. Consulta los roles predefinidos y los permisos de redes de servicios.

1. Crea estas variables de entorno:

   RANGE_NAME=YOUR_RANGE_NAME
   NETWORK_NAME=YOUR_NETWORK_NAME
   

   Donde:

   • RANGE_NAME es el nombre del intervalo de direcciones IP que vas a crear. Puedes asignar el nombre que quieras al intervalo. Por ejemplo: google-svcs
   • NETWORK_NAME es el nombre del recurso de red en el que se deben reservar las direcciones.

     Google crea una red predeterminada (llamada default) para cada proyecto nuevo, por lo que puedes usarla. Sin embargo, Google no recomienda usar la red predeterminada para nada que no sean pruebas.

     Nota: Google no recomienda usar default a menos que estés probando este proceso de configuración. No debes usar una organización con una red predeterminada en producción.
2. Crea un intervalo de IP de red con una longitud CIDR de /22:

   gcloud compute addresses create $RANGE_NAME \
     --global \
     --prefix-length=22 \
     --description="Peering range for Apigee services" \
     --network=$NETWORK_NAME \
     --purpose=VPC_PEERING \
     --addresses=OPTIONAL_ADDRESSES \
     --project=$PROJECT_ID

   Donde --addresses te permite especificar de forma opcional un intervalo de direcciones. Por ejemplo, para asignar el bloque CIDR 192.168.0.0/22, especifica 192.168.0.0 para la dirección y 22 para la longitud del prefijo. Consulta también Crear una asignación de IP.

   Si no proporcionas el parámetro --addresses, gcloud seleccionará un intervalo de direcciones disponible.

   Si la solicitud se realiza correctamente, gcloud responde con lo siguiente:

   Created [https://www.googleapis.com/compute/v1/projects/PROJECT_NAME/global/addresses/google-svcs].

   Una vez que creas un intervalo de direcciones IP, estas se asocian al proyecto hasta que las liberas.

3. Verifica que el intervalo de IP de la red se haya creado con una longitud CIDR de /22:

   gcloud compute addresses list --global --project=$PROJECT_ID
   gcloud compute addresses describe $RANGE_NAME --global --project=$PROJECT_ID

4. Crea un intervalo de IP de red con una longitud CIDR de /28. Este intervalo es obligatorio y Apigee lo usa para solucionar problemas. No se puede personalizar ni cambiar.

   gcloud compute addresses create google-managed-services-support-1 \
     --global \
     --prefix-length=28 \
     --description="Peering range for supporting Apigee services" \
     --network=$NETWORK_NAME \
     --purpose=VPC_PEERING \
     --addresses=OPTIONAL_ADDRESSES \
     --project=$PROJECT_ID

   Donde --addresses te permite especificar de forma opcional un intervalo de direcciones. Por ejemplo, para asignar el bloque CIDR 192.168.0.0/28, especifica 192.168.0.0 para la dirección y 28 para la longitud del prefijo. Consulta también Crear una asignación de IP.

   Si no proporcionas el parámetro --addresses, gcloud seleccionará un intervalo de direcciones disponible.

5. Comprueba que el intervalo de IP de la red se haya creado con una longitud CIDR de /28:

   gcloud compute addresses list --global --project=$PROJECT_ID
   gcloud compute addresses describe google-managed-services-support-1 --global \
     --project=$PROJECT_ID

6. Conecta tus servicios a la red con el siguiente comando:

   gcloud services vpc-peerings connect \
     --service=servicenetworking.googleapis.com \
     --network=$NETWORK_NAME \
     --ranges=$RANGE_NAME,google-managed-services-support-1 \
     --project=$PROJECT_ID

   Esta operación puede tardar varios minutos en completarse. Si la solicitud se completa correctamente, gcloud responde con lo siguiente, donde OPERATION_ID es el UUID de la LRO.

   Operation "operations/OPERATION_ID" finished successfully.

Apigee crea una conexión entre tu red y los servicios de Google. En concreto, Apigee conecta tu proyecto a la API Service Networking mediante el emparejamiento de VPC. Apigee también asocia direcciones IP a tu proyecto.

7. Al cabo de unos minutos, comprueba si el peering de VPC se ha realizado correctamente:

   gcloud services vpc-peerings list \
     --network=$NETWORK_NAME \
     --service=servicenetworking.googleapis.com \
     --project=$PROJECT_ID

Paso 5: Crea una organización

Permisos que se necesitan para completar esta tarea

Puedes asignar al aprovisionador de Apigee un rol predefinido que incluya los permisos necesarios para completar esta tarea o conceder permisos más específicos para proporcionar los privilegios mínimos necesarios. Consulta los siguientes artículos:

• Roles predefinidos
• Permisos del asistente de aprovisionamiento
• Permisos de creación de organizaciones (organización de pago).

Antes de crear una organización, debes crear un conjunto de claves y una clave de cifrado de la base de datos de tiempo de ejecución (consulta el paso 1) y, si usas la residencia de datos, conjuntos de claves y claves de cifrado del plano de control (consulta el paso 2). Estas claves de Cloud KMS cifran los datos que se almacenan y replican en las ubicaciones del tiempo de ejecución y del plano de control. Apigee usa estas entidades para cifrar datos de aplicaciones, como KVMs, caché y secretos de clientes, que se almacenan en la base de datos. Para obtener más información, consulta el artículo Acerca de las claves de cifrado de Apigee.

1. Crea un conjunto de claves y una clave de cifrado de la base de datos de tiempo de ejecución.

   1. Define una variable de entorno para la ubicación de tu base de datos de tiempo de ejecución anillo y clave de cifrado. De esta forma, se asegura la coherencia al crearlos y te resulta más fácil seguir la documentación.

      El valor es la ubicación física donde se almacenan el conjunto de claves y la clave de cifrado de la base de datos de tiempo de ejecución.

      Una sola región

      Configuraciones de una sola región (en las que solo tienes una instancia en una región): elige una de las ubicaciones regionales de KMS admitidas.

      Por ejemplo:

      RUNTIMEDBKEY_LOCATION="us-west1"

      El valor puede ser el mismo que el de $RUNTIME_LOCATION (que también es una región), pero no es obligatorio. Sin embargo, puede que el rendimiento mejore si son iguales.

      Multirregional

      Configuraciones multirregionales: elige entre las ubicaciones multirregionales admitidas (como us o europe) o las ubicaciones birregionales.

      Por ejemplo:

      RUNTIMEDBKEY_LOCATION="us"

      Si tienes una configuración multirregional en EE. UU., te recomendamos que uses us para tu ubicación, si es posible. Si no, usa nam4.

   2. Define variables de entorno para los conjuntos de claves y los nombres de las claves de la base de datos.

      El nombre del conjunto de claves debe ser único en tu organización. Si creas una segunda región o una posterior, el nombre no puede ser el mismo que el de otros conjuntos de claves.

      RUNTIMEDB_KEY_RING_NAME=YOUR_DB_KEY_RING_NAME
      RUNTIMEDB_KEY_NAME=YOUR_DB_KEY_NAME

   3. (Opcional) Comprueba tu trabajo repitiendo los valores que acabas de definir. Recuerda que, si quieres usar una variable en tus comandos, debes poner el signo de dólar ($) delante del nombre de la variable.

      echo $RUNTIMEDBKEY_LOCATION
      echo $RUNTIMEDB_KEY_RING_NAME
      echo $RUNTIMEDB_KEY_NAME

   4. Para crear un conjunto de claves:

      gcloud kms keyrings create $RUNTIMEDB_KEY_RING_NAME \
        --location $RUNTIMEDBKEY_LOCATION --project $PROJECT_ID

      La ubicación de la clave de cifrado de la base de datos de tiempo de ejecución de Apigee admite todas las ubicaciones de Cloud KMS que admiten Cloud HSM y Cloud EKM.

   5. Para crear una clave, sigue estos pasos:

      gcloud kms keys create $RUNTIMEDB_KEY_NAME \
        --keyring $RUNTIMEDB_KEY_RING_NAME \
        --location $RUNTIMEDBKEY_LOCATION \
        --purpose "encryption" \
        --project $PROJECT_ID

      Este comando crea la clave y la añade al conjunto de claves.

      Obtén el ID de la clave:

      gcloud kms keys list \
        --location=$RUNTIMEDBKEY_LOCATION \
        --keyring=$RUNTIMEDB_KEY_RING_NAME \
        --project=$PROJECT_ID

      El ID de clave tiene la siguiente sintaxis (similar a una ruta de archivo):

      projects/PROJECT_ID/locations/RUNTIMEDBKEY_LOCATION/keyRings/RUNTIMEDB_KEY_RING_NAME/cryptoKeys/RUNTIMEDB_KEY_NAME

   6. Coloca el ID de la clave en una variable de entorno. Usarás esta variable en un comando posterior:

      RUNTIMEDB_KEY_ID=YOUR_RUNTIMEDB_KEY_ID

   7. Concede acceso al agente de servicio de Apigee para que use la nueva clave:

      gcloud kms keys add-iam-policy-binding $RUNTIMEDB_KEY_NAME \
        --location $RUNTIMEDBKEY_LOCATION \
        --keyring $RUNTIMEDB_KEY_RING_NAME \
        --member serviceAccount:service-$[e-mail] \
        --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
        --project $PROJECT_ID

      Este comando vincula la clave al agente de servicio de Apigee.

      Si esta solicitud se completa correctamente, gcloud responde con un mensaje similar al siguiente:

      Updated IAM policy for key [runtime].
      bindings:
      - members:
        - serviceAccount:[e-mail]
        role: roles/cloudkms.cryptoKeyEncrypterDecrypter
      etag: BwWqgEuCuwk=
      version: 1

      Si aparece un error como el siguiente:

      INVALID_ARGUMENT: Role roles/cloudkms.cryptokms.cryptoKeyEncrypterDecrypter is not supported for this resource.

      Asegúrate de haber usado el número del proyecto y no el nombre en la dirección de correo de la cuenta de servicio.

2. Si usas la residencia de datos, crea un conjunto de claves y una clave de encriptado del plano de control. Si no usa la residencia de datos, vaya al paso 3.
   Nota: Este paso solo es obligatorio si has seleccionado us (multiple regions in us) o eu (multiple regions in European Union) como jurisdicción de alojamiento del plano de control. Si has seleccionado otra región, ve al paso 3.

Sigue estos pasos para crear un conjunto de claves y una clave de cifrado del plano de control.

1. Define una variable de entorno para la ubicación del anillo y la clave de cifrado de la base de datos del plano de control:

   CONTROL_PLANE_LOCATION=YOUR_CONTROL_PLANE_LOCATION
   CONSUMER_DATA_REGION=YOUR_CONSUMER_DATA_REGION

   Donde:

   • CONTROL_PLANE_LOCATION es la ubicación física en la que se almacenarán los datos del plano de control de Apigee. Para ver una lista de las ubicaciones del plano de control disponibles, consulta Ubicaciones de Apigee.
   • CONSUMER_DATA_REGION es una subregión de la región del plano de control. Debes especificar tanto CONTROL_PLANE_LOCATION como CONSUMER_DATA_REGION. Para ver una lista de las regiones de datos de consumidores disponibles, consulta Ubicaciones de Apigee.

2. Define variables de entorno para los conjuntos de claves y los nombres de las claves de la base de datos del plano de control.

   El nombre del conjunto de claves debe ser único en tu organización.

   CONTROL_PLANE_KEY_RING_NAME=YOUR_CONTROL_PLANE_KEY_RING_NAME
   CONTROL_PLANE_KEY_NAME=YOUR_CONTROL_PLANE_KEY_NAME
   CONSUMER_DATA_KEY_RING_NAME=YOUR_CONSUMER_DATA_KEY_RING_NAME
   CONSUMER_DATA_KEY_NAME=YOUR_CONSUMER_DATA_REGION_KEY_NAME

   Donde:

   • CONTROL_PLANE_KEY_RING_NAME es el nombre del conjunto de claves que usarás para identificar tu conjunto de claves de cifrado del plano de control.
   • CONTROL_PLANE_KEY_NAME es el nombre de la clave que usarás para identificar tu clave de cifrado del plano de control.
   • CONSUMER_DATA_KEY_RING_NAME es el nombre del conjunto de claves que usarás para identificar tu conjunto de claves de cifrado de la región de datos de consumidor.
   • CONSUMER_DATA_KEY_NAME es el nombre de la clave que usarás para identificar tu clave de cifrado de la región de datos de consumidor.
3. Para crear un conjunto de claves:

   gcloud kms keyrings create $CONTROL_PLANE_KEY_RING_NAME \
     --location $CONTROL_PLANE_LOCATION \
     --project $PROJECT_ID

   gcloud kms keyrings create $CONSUMER_DATA_KEY_RING_NAME \
     --location $CONSUMER_DATA_REGION \
     --project $PROJECT_ID

4. Para crear una clave, sigue estos pasos:

   gcloud kms keys create $CONTROL_PLANE_KEY_NAME \
     --keyring $CONTROL_PLANE_KEY_RING_NAME \
     --location $CONTROL_PLANE_LOCATION \
     --purpose "encryption" \
     --project $PROJECT_ID

   gcloud kms keys create $CONSUMER_DATA_KEY_NAME \
     --keyring $CONSUMER_DATA_KEY_RING_NAME \
     --location $CONSUMER_DATA_REGION \
     --purpose "encryption" \
     --project $PROJECT_ID

   Este comando crea la clave y la añade al conjunto de claves.

   Obtén el ID de la clave:

   gcloud kms keys list \
   --location=$CONTROL_PLANE_LOCATION \
   --keyring=$CONTROL_PLANE_KEY_RING_NAME \
   --project=$PROJECT_ID

   gcloud kms keys list \
   --location=$CONSUMER_DATA_REGION \
   --keyring=$CONSUMER_DATA_KEY_RING_NAME \
   --project=$PROJECT_ID

   El ID de clave tiene la siguiente sintaxis (similar a una ruta de archivo):

   projects/PROJECT_ID/locations/CONTROL_PLANE_LOCATION/keyRings/CONTROL_PLANE_KEY_RING_NAME/cryptoKeys/CONTROL_PLANE_KEY_NAME

   projects/PROJECT_ID/locations/CONSUMER_DATA_REGION/keyRings/CONSUMER_DATA_KEY_RING_NAME/cryptoKeys/CONSUMER_DATA_KEY_NAME

5. Coloca el ID de la clave en una variable de entorno. Usarás esta variable en un comando posterior:

   CONTROL_PLANE_KEY_ID=YOUR_CONTROL_PLANE_KEY_ID
   

   CONSUMER_DATA_KEY_ID=YOUR_CONSUMER_DATA_KEY_ID

6. Concede acceso al agente de servicio de Apigee para que use la nueva clave:

   gcloud kms keys add-iam-policy-binding $CONTROL_PLANE_KEY_NAME \
     --location $CONTROL_PLANE_LOCATION \
     --keyring $CONTROL_PLANE_KEY_RING_NAME \
     --member "serviceAccount:service-$[e-mail]" \
     --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
     --project $PROJECT_ID
   

   gcloud kms keys add-iam-policy-binding $CONSUMER_DATA_KEY_NAME \
    --location $CONSUMER_DATA_REGION \
    --keyring $CONSUMER_DATA_KEY_RING_NAME \
    --member "serviceAccount:service-$[e-mail]" \
    --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
    --project $PROJECT_ID
   

   Este comando vincula la clave al agente de servicio de Apigee. Si esta solicitud se completa correctamente, gcloud responde con un mensaje similar al siguiente:

   Updated IAM policy for key [runtime].
   bindings:
   - members:
     - serviceAccount:[e-mail]
     role: roles/cloudkms.cryptoKeyEncrypterDecrypter
   etag: BwWqgEuCuwk=
   version: 1

   Si aparece un error como el siguiente:

   INVALID_ARGUMENT: Role roles/cloudkms.cryptokms.cryptoKeyEncrypterDecrypter is not supported for this resource.

   Asegúrate de haber usado el número del proyecto y no el nombre del proyecto en la dirección de correo de la cuenta de servicio.

Consulta también la sección Solución de problemas de CMEK.

3. Para crear la organización, envía la siguiente solicitud a la API organizations de Apigee:

   Sin residencia de datos

   curl "https://apigee.googleapis.com/v1/organizations?parent=projects/$PROJECT_ID"  \
     -H "Authorization: Bearer $AUTH" \
     -X POST \
     -H "Content-Type:application/json" \
     -d '{
       "name":"'"$PROJECT_ID"'",
       "analyticsRegion":"'"$ANALYTICS_REGION"'",
       "runtimeType":"CLOUD",
       "billingType":"'"$BILLING_TYPE"'",
       "authorizedNetwork":"'"$NETWORK_NAME"'",
       "runtimeDatabaseEncryptionKeyName":"'"$RUNTIMEDB_KEY_ID"'"
     }'

   Donde:

   • -d define la carga útil de datos de la solicitud. Esta carga útil debe incluir lo siguiente:

     • name: identifica tu nueva organización. Debe ser el mismo nombre que el ID de tu proyecto.

     • analyticsRegion: especifica la ubicación física en la que se almacenarán sus datos analíticos.

     • runtimeType: asigna el valor CLOUD.
     • billingType: especifica el tipo de facturación de la organización creada.
     • authorizedNetwork: identifica la red de interconexión que has especificado en Configurar la red de servicios.
       Nota: Apigee también admite el uso de una VPC compartida (es decir, el proyecto de red del host no es el mismo que el que está emparejado con Apigee). Para usar una red de VPC compartida, utiliza el siguiente formato: projects/HOST_PROJECT_ID/REGION/networks/NETWORK_NAME. Por ejemplo:
       projects/my-sharedvpc-host/global/networks/mynetwork

       Consulta también la descripción general de las VPC y el recurso REST organizations.

     • runtimeDatabaseEncryptionKeyName: el ID de la clave de cifrado de la aplicación que has creado en el paso anterior. Recuerda que el ID tiene una estructura similar a la de una ruta de archivo. Por ejemplo:
       projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key

   Residencia de datos

   Crea una organización con la API:

   curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations?parent=projects/$PROJECT_ID"  \
     -H "Authorization: Bearer $AUTH" \
     -X POST \
     -H "Content-Type:application/json" \
     -d '{
       "name":"'"$PROJECT_ID"'",
       "runtimeType":"CLOUD",
       "billingType":"'"$BILLING_TYPE"'",
       "controlPlaneEncryptionKeyName":"'"$CONTROL_PLANE_KEY_ID"'",
       "apiConsumerDataLocation":"'"$CONSUMER_DATA_REGION"'",
       "apiConsumerDataEncryptionKeyName":"'"$CONSUMER_DATA_KEY_ID"'",
       "authorizedNetwork":"'"$NETWORK_NAME"'",
       "runtimeDatabaseEncryptionKeyName":"'"$RUNTIMEDB_KEY_ID"'"
     }'

   Donde:

   -d define la carga útil de datos de la solicitud. Esta carga útil debe incluir lo siguiente:

   • name: identifica tu nueva organización. Debe ser el mismo nombre que el ID de tu proyecto.
   • runtimeType: asigna el valor CLOUD.
   • billingType: especifica el tipo de facturación de la organización creada.
   • controlPlaneEncryptionKeyName: es el ID de la clave del plano de control.
   • apiConsumerDataLocation: También debes especificar una subregión para que la usen los recursos internos. Consulta Regiones de residencia de datos para ver los valores admitidos.
   • apiConsumerDataEncryptionKeyName: es el ID de la clave de la región de tus datos de consumidor.
   • authorizedNetwork: identifica la red de interconexión que has especificado en Configurar la red de servicios.
     Nota: Apigee también admite el uso de una VPC compartida (es decir, el proyecto de red del host no es el mismo que el que está emparejado con Apigee). Para usar una red de VPC compartida, utiliza el siguiente formato: projects/HOST_PROJECT_ID/REGION/networks/NETWORK_NAME. Por ejemplo:
     projects/my-sharedvpc-host/global/networks/mynetwork

     Consulta también la descripción general de las VPC y el recurso REST organizations.

   • runtimeDatabaseEncryptionKeyName: el ID de la clave de cifrado de la aplicación que has creado en el paso anterior. Recuerda que el ID tiene la estructura de una ruta de archivo. Por ejemplo:
     projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key

   Después de ejecutar este comando, Apigee inicia una operación de larga duración, que puede tardar unos minutos en completarse.

   Si se produce un error, comprueba que has usado comillas alrededor de los valores de las variables en la carga útil de datos. Asegúrate de que la variable $PROJECT_ID esté entre comillas dobles, simples y dobles, como se muestra en el siguiente ejemplo:

   "'"$PROJECT_ID"'"

   Si usa cadenas simples (no variables de entorno) para los valores de las solicitudes, puede incluirlas entre comillas dobles en la cadena de carga útil entre comillas simples, como se muestra en el siguiente ejemplo:

   '{ "name":"my-gcp-project", ... }'

4. Espera unos minutos.
5. Para comprobar el estado de tu solicitud de creación, puedes enviar una solicitud GET a la API List organizations de Apigee, como se muestra en el siguiente ejemplo:

   Sin residencia de datos

   curl -H "Authorization: Bearer $AUTH" "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID"

   Residencia de datos

   curl -H "Authorization: Bearer $AUTH" "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID"

   Si ves esta respuesta, significa que la creación de la organización aún no se ha completado:

   {
     "error": {
       "code": 403,
       "message": "Permission denied on resource \"organizations/apigee-docs-m\" (or it may not exist)",
       "status": "PERMISSION_DENIED"
     }
   }

   Si Apigee ha creado una organización correctamente, recibirás una respuesta similar a la siguiente:

   Sin residencia de datos

   {
     "name": "my-cloud-project",
     "createdAt": "1592586495539",
     "lastModifiedAt": "1592586495539",
     "environments": [],
     "properties": {
       "property": [
         {
           "name": "features.hybrid.enabled",
           "value": "true"
         },
         {
           "name": "features.mart.connect.enabled",
           "value": "true"
         }
       ]
     },
     "analyticsRegion": "us-west1",
     "runtimeType": "CLOUD",
     "subscriptionType": "PAID",
     "caCertificate": "YOUR_CERTIFICATE",
     "authorizedNetwork": "my-network",
     "projectId": "my-cloud-project"
   }

   Residencia de datos

     {
       "name": "my-cloud-project",
       "createdAt": "1681412783749",
       "lastModifiedAt": "1681412783749",
       "environments": [
         "test-env"
       ],
       "properties": {
         "property": [
           {
             "name": "features.mart.connect.enabled",
             "value": "true"
           },
           {
             "name": "features.hybrid.enabled",
             "value": "true"
           }
         ]
       },
       "authorizedNetwork": "default",
       "runtimeType": "CLOUD",
       "subscriptionType": "PAID",
       "caCertificate": "YOUR_CERTIFICATE",
       "runtimeDatabaseEncryptionKeyName": "projects/my-cloud-project/locations/us/keyRings/my-key-ring/cryptoKeys/my-key-name",
       "projectId": "my-cloud-project",
       "state": "ACTIVE",
       "billingType": "PAYG",
       "addonsConfig": {
         "advancedApiOpsConfig": {},
         "integrationConfig": {},
         "monetizationConfig": {},
         "connectorsPlatformConfig": {}
       },
       "apiConsumerDataEncryptionKeyName": "projects/my-cloud-project/locations/us-central1/keyRings/my-key-ring/cryptoKeys/my-key-name",
       "controlPlaneEncryptionKeyName": "projects/my-cloud-project/locations/us/keyRings/my-key-ring/cryptoKeys/my-key-name",
       "apiConsumerDataLocation": "us-central1",
       "apigeeProjectId": "i0c2a37e80f9850ab-tp"
     }
   
   

   Si Apigee devuelve una respuesta de error HTTP, consulta el artículo Crear una organización de Apigee.

Nota: Para enumerar las organizaciones de Apigee y los proyectos de Google Cloud asociados a los que tienes permiso para acceder, envía una solicitud GET al siguiente endpoint mediante la API organizations:

• Sin residencia de datos:

  curl -H "Authorization: Bearer $AUTH" https://apigee.googleapis.com/v1/organizations/

• Residencia de datos:

  curl -H "Authorization: Bearer $AUTH" https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/

Apigee devuelve una lista de proyectos, como se muestra en el siguiente ejemplo:

{
  "organizations": [
    {
      "organization": "my-cloud-project",
      "projectIds": [
        "my-cloud-project"
      ],
      "projectId": "my-cloud-project",
      "location": "northamerica-northeast1"
    },
    {
      "organization": "my-cloud-project-2",
      "projectIds": [
        "my-cloud-project-2"
      ],
      "projectId": "my-cloud-project-2",
      "location": "northamerica-northeast1"
    }
  ]
}

Paso 6: Crea una instancia de entorno de ejecución

Permisos que se necesitan para completar esta tarea

Puedes asignar al aprovisionador de Apigee un rol predefinido que incluya los permisos necesarios para completar esta tarea o conceder permisos más específicos para proporcionar los privilegios mínimos necesarios. Consulta los artículos sobre roles predefinidos y permisos de instancias de tiempo de ejecución.

Una instancia de tiempo de ejecución es el lugar donde se almacenan tu proyecto de Apigee y los servicios relacionados. Proporciona el endpoint visible para los usuarios de tus servicios. Para crear una instancia de tiempo de ejecución:

1. Comprueba que Apigee haya terminado de crear tu organización. Has enviado una solicitud para crear una organización en Crear una organización de Apigee, pero debes asegurarte de que se haya completado antes de continuar.

   Para ello, envíe la siguiente solicitud a la API Organizations:

   Sin residencia de datos

   curl -i -H "Authorization: Bearer $AUTH" \
       "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID"

   Residencia de datos

   curl -i -H "Authorization: Bearer $AUTH" \
       "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID"

   Si la organización existe (y tienes los permisos adecuados para verla), Apigee responde con información detallada sobre ella. Si Apigee responde con un error, espera un par de minutos y vuelve a enviar la solicitud.

2. Al igual que en la tarea anterior, en la que creaste una clave de cifrado para la base de datos, ahora debes crear una clave de Cloud KMS que se use para cifrar datos del lado del servidor. Para empezar, define las siguientes variables de entorno:

   INSTANCE_NAME=YOUR_INSTANCE_NAME
   RUNTIME_LOCATION=YOUR_RUNTIME_LOCATION
   DISK_KEY_RING_NAME=YOUR_DISK_KEY_RING_NAME
   DISK_KEY_NAME=YOUR_DISK_KEY_NAME

Donde:

• INSTANCE_NAME: nombre de la nueva instancia. Por ejemplo, my-runtime-instance. El nombre debe empezar por una letra en minúscula, tener una longitud máxima de 32 caracteres y solo puede incluir letras en minúscula, números y guiones. No puede empezar ni acabar con un guion y debe tener al menos dos caracteres.
  Nota: El nombre de la instancia debe coincidir con la siguiente expresión regular:

  ^[a-z][a-z\-\d]{0,30}[a-z\d]$

• RUNTIME_LOCATION es el lugar físico en el que se aloja tu clúster. Los valores válidos son cualquier ubicación permitida por Compute Engine. (Consulta las regiones y zonas disponibles). En este ejemplo se usa us-west1.
• DISK_KEY_RING_NAME es el nombre del conjunto de claves de cifrado de disco.
• DISK_KEY_NAME es el nombre de la clave de cifrado de disco.
3. Crea una clave de cifrado del disco:
   1. Crea un conjunto de claves de disco:

      gcloud kms keyrings create $DISK_KEY_RING_NAME \
        --location $RUNTIME_LOCATION \
        --project $PROJECT_ID

      El conjunto de claves de disco debe estar en la misma ubicación que la instancia. Cada instancia y llavero debe tener su propia ubicación.

   2. Crea una clave de disco:

      gcloud kms keys create $DISK_KEY_NAME \
        --keyring $DISK_KEY_RING_NAME \
        --location $RUNTIME_LOCATION \
        --purpose "encryption" \
        --project $PROJECT_ID

      Se puede hacer referencia a la clave mediante su ruta de clave. Puedes obtener la ruta de la clave con el siguiente comando:

      gcloud kms keys list \
        --location=$RUNTIME_LOCATION \
        --keyring=$DISK_KEY_RING_NAME \
        --project=$PROJECT_ID

      La ruta de la clave tiene un aspecto similar al siguiente:

      projects/PROJECT_ID/locations/RUNTIME_LOCATION/keyRings/my-disk-key-ring/cryptoKeys/my-disk-key

   3. Coloca la ruta de la clave en una variable de entorno. Usarás esta variable en un comando posterior:

      DISK_KEY_ID=YOUR_DISK_KEY_ID

      Por ejemplo: DISK_KEY_ID=projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key

   4. Concede acceso al agente de servicio de Apigee para que use la nueva clave:

      gcloud kms keys add-iam-policy-binding $DISK_KEY_NAME \
        --location $RUNTIME_LOCATION \
        --keyring $DISK_KEY_RING_NAME \
        --member serviceAccount:service-$[e-mail] \
        --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
        --project $PROJECT_ID

      Este comando vincula la clave al agente de servicio de Apigee.

   Para obtener más información, consulta el artículo Acerca de las claves de cifrado de Apigee.

4. Para crear una instancia de tiempo de ejecución para tu proyecto, envía una solicitud POST a la API Instances de Apigee:

   Sin residencia de datos

   curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances" \
     -X POST -H "Authorization: Bearer $AUTH" \
     -H "Content-Type:application/json" \
     -d '{
       "name":"'"$INSTANCE_NAME"'",
       "location":"'"$RUNTIME_LOCATION"'",
       "diskEncryptionKeyName":"'"$DISK_KEY_ID"'",
       "consumerAcceptList":["'"$PROJECT_ID"'"]
     }'

   Residencia de datos

   curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances" \
     -X POST -H "Authorization: Bearer $AUTH" \
     -H "Content-Type:application/json" \
     -d '{
       "name":"'"$INSTANCE_NAME"'",
       "location":"'"$RUNTIME_LOCATION"'",
       "diskEncryptionKeyName":"'"$DISK_KEY_ID"'",
       "consumerAcceptList":["'"$PROJECT_ID"'"]
     }'

   Donde:

   • consumerAcceptList (Opcional) Especifica una lista de IDs de proyectos de Google Cloud que pueden conectarse de forma privada al adjunto de servicio de la VPC de Apigee. Una vinculación de servicio es una entidad que se usa con Private Service Connect de Google Cloud para permitir que los productores de servicios (en este caso, Apigee) expongan servicios a los consumidores (en este caso, uno o varios proyectos de Cloud de tu propiedad). De forma predeterminada, usamos el proyecto de Cloud que ya está asociado a tu organización de Apigee. Por ejemplo: "consumerAcceptList": ["project1", "project2", "project3"]

     Ten en cuenta que también puedes definir y cambiar la lista de proyectos aceptados en la interfaz de usuario de la instancia. Para obtener más información, consulta el artículo Gestionar instancias.

   Nota: De forma predeterminada, Apigee asigna automáticamente a la instancia los intervalos de IPs de red /22 y /28 reservados anteriormente en el paso 4: Configurar la red de servicios.

   En casos prácticos avanzados, como cuando has reservado varios intervalos /22 y /28 o un bloque de intervalos más grande, como /16, en el paso 4: Configurar la red de servicios y quieres controlar los intervalos asignados a la instancia, es posible que tengas que especificar exactamente el intervalo de IPs que quieres que use Apigee. En estos casos, debe especificar un intervalo de IPs personalizado con el prefijo /22 o /28, o ambos. Los intervalos deben estar disponibles como parte de una conexión privada entre tu proyecto y Apigee.

   Para personalizar los intervalos de IPs, usa el parámetro de solicitud ipRange tal como se describe en el documento de referencia de la API Instances , como se explica a continuación:

   1. Crea una variable de entorno que contenga los intervalos de IP en formato CIDR:

      MY_IP_RANGES=CIDR_RANGES

      Por ejemplo:

      MY_IP_RANGES=10.0.0.1/22             // To specify only /22 range.
      MY_IP_RANGES=10.0.0.1/22,10.0.0.2/28 // To specify both /22 and /28 ranges.
      

      Nota: Puedes personalizar solo /22 o /28, o ambos. Si proporcionas /22 o /28, Apigee asigna automáticamente el otro intervalo del intervalo de IPs reservado en el paso 4: Configurar la red de servicios.
   2. Crea la instancia con el parámetro ipRange:

      • Sin residencia de datos:

        curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances" \
          -X POST -H "Authorization: Bearer $AUTH" \
          -H "Content-Type:application/json" \
          -d '{
            "name":"'"$INSTANCE_NAME"'",
            "location":"'"$RUNTIME_LOCATION"'",
            "diskEncryptionKeyName":"'"$DISK_KEY_ID"'",
            "ipRange":"'"$MY_IP_RANGES"'",
            "consumerAcceptList":[ARRAY_OF_PROJECT_IDS]
          }'

      • Residencia de datos:

        curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances" \
          -X POST -H "Authorization: Bearer $AUTH" \
          -H "Content-Type:application/json" \
          -d '{
            "name":"'"$INSTANCE_NAME"'",
            "location":"'"$RUNTIME_LOCATION"'",
            "diskEncryptionKeyName":"'"$DISK_KEY_ID"'",
            "ipRange":"'"$MY_22_RANGE,$MY_28_RANGE"'",
            "consumerAcceptList":[ARRAY_OF_PROJECT_IDS]
          }'

   Ten en cuenta que, una vez creado, no podrás cambiar el intervalo de IPs. Si alguna vez necesitas cambiar el intervalo, tendrás que crear una instancia nueva.

   Aunque el intervalo de IPs /22 se usa para ejecutar cargas de trabajo principales de Apigee, Apigee usa el intervalo /28 para acceder a la instancia con fines de solución de problemas. Consulta también Crear instancias.

   Esta solicitud puede tardar hasta 20 minutos en completarse, ya que Apigee debe crear e iniciar un nuevo clúster de Kubernetes, instalar los recursos de Apigee en ese clúster y configurar el balanceo de carga.

   Si Apigee devuelve un error, consulta Crear una instancia.

5. Para comprobar el estado de tu solicitud de creación de instancias de tiempo de ejecución, ejecuta el siguiente comando. Cuando el estado sea ACTIVO, puedes continuar con el siguiente paso.

   Sin residencia de datos

   curl -i -X GET -H "Authorization: Bearer $AUTH" \
       "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME"

   Residencia de datos

   curl -i -X GET -H "Authorization: Bearer $AUTH" \
       "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME"

Paso 7: Crea un entorno

Permisos que se necesitan para completar esta tarea

Puedes asignar al aprovisionador de Apigee un rol predefinido que incluya los permisos necesarios para completar esta tarea o conceder permisos más específicos para proporcionar los privilegios mínimos necesarios. Consulta los siguientes artículos:

• Roles predefinidos
• Permisos del asistente de aprovisionamiento

Para crear un entorno y asociarlo al tiempo de ejecución en la línea de comandos, sigue estos pasos:

1. Define las variables de entorno que se van a usar en esta sección.

   En un entorno de pago por uso, crea estas variables:

   ENVIRONMENT_NAME="YOUR_ENV_NAME"
   ENVIRONMENT_TYPE="YOUR_ENV_TYPE"
   ENV_GROUP_NAME="YOUR_ENV_GROUP_NAME"
   ENV_GROUP_HOSTNAME="YOUR_ENV_GROUP_HOSTNAME"

   Donde:

   • ENVIRONMENT_NAME es un nombre de cadena. Por ejemplo: test
   • ENVIRONMENT_TYPE es el tipo de entorno de este entorno y solo se aplica a los usuarios de Pay-as-you-go, que deben especificar uno de estos valores: BASE, INTERMEDIATE o COMPREHENSIVE. Los demás usuarios deben omitir el tipo de entorno.
   • ENV_GROUP_NAME es un nombre de cadena. Por ejemplo: test-group
   • ENV_GROUP_HOSTNAME es un nombre de host de dominio válido. Por ejemplo: foo.example.com
2. Crea un entorno con la API Environments.

   Para crear un entorno de pago por uso, usa el siguiente comando:

   Sin residencia de datos

   curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments" \
       -H "Authorization: Bearer $AUTH" \
       -X POST \
       -H "Content-Type:application/json" \
       -d '{
         "name":"'"$ENVIRONMENT_NAME"'",
         "type":"'"$ENVIRONMENT_TYPE"'"
     }'

   Residencia de datos

   curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments" \
       -H "Authorization: Bearer $AUTH" \
       -X POST \
       -H "Content-Type:application/json" \
       -d '{
         "name":"'"$ENVIRONMENT_NAME"'",
         "type":"'"$ENVIRONMENT_TYPE"'"
     }'

   Apigee crea un nuevo entorno.

3. Antes de continuar, comprueba que Apigee ha terminado de crear el nuevo entorno llamando a la API Environments:

   Sin residencia de datos

   curl -i -H "Authorization: Bearer $AUTH" \
       "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments"

   Residencia de datos

   curl -i -H "Authorization: Bearer $AUTH" \
       "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments"

   Apigee responde con una lista de los entornos disponibles. Por ejemplo, si el nombre de tu entorno es test, Apigee responde con lo siguiente:

   [
     "test"
   ]

   Nota: Puedes consultar el estado de un entorno específico enviando un comando como el siguiente:

   • Sin residencia de datos:

     curl -i -X GET -H "Authorization: Bearer $AUTH" \
       "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME"

   • Residencia de datos:

     curl -i -X GET -H "Authorization: Bearer $AUTH" \
                   "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME"

   Apigee responde con detalles sobre ese entorno únicamente. Por ejemplo:

   {
     "name": "my-cloud-project",
     "createdAt": "1592589683002",
     "lastModifiedAt": "1592589683002",
     "state": "ACTIVE"
   }

4. Adjunta el nuevo entorno a la instancia del entorno de ejecución:

   Sin residencia de datos

   curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments" \
       -X POST -H "Authorization: Bearer $AUTH" \
       -H "content-type:application/json" \
       -d '{
         "environment":"'"$ENVIRONMENT_NAME"'"
       }'

   Residencia de datos

   curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments" \
       -X POST -H "Authorization: Bearer $AUTH" \
       -H "content-type:application/json" \
       -d '{
         "environment":"'"$ENVIRONMENT_NAME"'"
       }'

   Esta operación puede tardar varios minutos en completarse. Para comprobar si se ha completado el adjunto, ejecuta este comando:

   Sin residencia de datos

   curl -i -H "Authorization: Bearer $AUTH" \
     "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments"

   Residencia de datos

   curl -i -H "Authorization: Bearer $AUTH" \
     "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments"

   Cuando veas un resultado como el siguiente, puedes ir al siguiente paso:

   {
     "attachments": [
       {
         "name": "ed628782-c893-4095-b71c-f4731805290a",
         "environment": "test",
         "createdAt": "1641604447542"
       }
     ]
   }

5. Crea un nuevo grupo de entornos con el siguiente comando. Para obtener más información, consulta Acerca de los entornos y los grupos de entornos:

   Sin residencia de datos

   curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups" \
       -H "Authorization: Bearer $AUTH" \
       -X POST \
       -H "Content-Type:application/json" \
       -d '{
         "name": "'"$ENV_GROUP_NAME"'",
         "hostnames":["'"$ENV_GROUP_HOSTNAME"'"]
     }'

   Residencia de datos

   curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups" \
       -H "Authorization: Bearer $AUTH" \
       -X POST \
       -H "Content-Type:application/json" \
       -d '{
         "name": "'"$ENV_GROUP_NAME"'",
         "hostnames":["'"$ENV_GROUP_HOSTNAME"'"]
     }'

   Nota: Al adjuntar un entorno al grupo, los proxies de ese entorno se pueden enrutar a través de los nombres de host del grupo.
6. Espera a que termine la operación. Puedes consultar el estado de tu nuevo grupo con una solicitud como la siguiente:

   Sin residencia de datos

   curl -i -H "Authorization: Bearer $AUTH" \
       "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME"

   Residencia de datos

   curl -i -H "Authorization: Bearer $AUTH" \
       "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME"

7. Asocia el nuevo entorno al nuevo grupo de entornos con el siguiente comando:

   Sin residencia de datos

   curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME/attachments" \
       -X POST \
       -H "Authorization: Bearer $AUTH" \
       -H "content-type:application/json" \
       -d '{
         "environment":"'"$ENVIRONMENT_NAME"'"
     }'

   Residencia de datos

   curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME/attachments" \
       -X POST \
       -H "Authorization: Bearer $AUTH" \
       -H "content-type:application/json" \
       -d '{
         "environment":"'"$ENVIRONMENT_NAME"'"
     }'

8. Para comprobar el estado de la operación, llama a esta API:

   Sin residencia de datos

   curl -H "Authorization: Bearer $AUTH" \
       "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME/attachments"

   Residencia de datos

   curl -H "Authorization: Bearer $AUTH" \
       "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME/attachments"

Paso 8: Configura el enrutamiento

En este paso, se configura cómo se comunican las aplicaciones cliente con Apigee. El tráfico de cliente a Apigee también se denomina tráfico "de entrada". Las opciones de configuración de la comunicación hacia el norte son las siguientes. Ve a la opción de configuración que quieras usar y sigue los pasos correspondientes:

Tipo de acceso	Descripción del proceso de configuración e implementación
Interno con emparejamiento de VPCs	Permite solo el acceso interno a tus proxies de API. Debes crear una máquina virtual en la red y conectarte a ella. Desde la nueva VM, puedes enviar una solicitud a un proxy de API de Apigee.
Externo con MIG	Permite el acceso externo a tus proxies de API. Usa un grupo de instancias gestionado (MIG) para enviar tráfico de APIs desde el servicio de backend de un balanceador de carga global a Apigee. Con esta configuración, Apigee solo puede conectarse a la VPC emparejada. Esta configuración te permite enviar solicitudes de proxy de API de Apigee desde cualquier máquina con conexión de red.
Interno con PSC (novedad)	Permite solo el acceso interno a tus proxies de API desde cualquiera de tus proyectos de Google Cloud mediante Private Service Connect (PSC). PSC permite la conexión privada entre un productor de servicios (Apigee) y un consumidor de servicios (el proyecto de VPC emparejado u otros proyectos de Cloud que controles). Con este método, las solicitudes pasan por un endpoint de servicio o por un balanceador de carga interno regional hasta un único punto de conexión, denominado vinculación de servicio. Esta configuración permite que tus clientes internos envíen solicitudes de proxy de API de Apigee desde cualquier máquina con conexión de red.
Externo con PSC (nuevo)	Permite el acceso externo a tus proxies de API mediante Private Service Connect (PSC). Usa Private Service Connect (PSC) para habilitar la conexión privada entre un productor de servicios (Apigee) y un consumidor de servicios (el proyecto de VPC emparejado u otros proyectos de Cloud que controles). Con este método, las solicitudes pasan por un balanceador de carga externo global o por un balanceador de carga externo regional a un único punto de conexión, llamado vinculación de servicio. Esta configuración te permite enviar solicitudes de proxy de API de Apigee desde cualquier máquina con conexión de red.

En las instrucciones que se indican a continuación se explica cada uno de estos métodos de enrutamiento.

Rutas internas (VPC)

Para enrutar el tráfico de los clientes internos a Apigee, puedes usar la cancelación de TLS o no:

• Opciones de TLS: tienes dos opciones si quieres hacer llamadas a proxies de APIs desde clientes internos con TLS habilitado:
  • Opción 1: Configurar un balanceador de carga interno (ILB):
    1. Crea un grupo de instancias gestionado en tu proyecto. Para crear el MIG, sigue los pasos 8a, 8b y 8c de la pestaña Ruta externa (MIG).
    2. Crea y configura un balanceador de carga HTTPS(S) interno (ILB) y asocia el MIG que has creado al servicio de backend del ILB, tal como se explica en el artículo Configurar el balanceo de carga HTTP(S) interno con backends de grupos de instancias de VM. Con la configuración de ILB, tienes control total sobre los certificados de AC que se usan con el ILB.
       Nota: Cuando configure su ILB, asegúrese de especificar HTTPS como protocolo y proporcione un certificado SSL para que su balanceador de carga pueda comunicarse con el backend de Apigee.
    3. Ve a Llamar a un proxy de API con acceso solo para uso interno para probar la configuración.
  • Opción 2: Usar el nombre de dominio completo interno predeterminado y la IP del balanceador de carga interno de la instancia de Apigee. Este caso solo se recomienda para hacer pruebas y no para un entorno de producción. En este caso, se usan certificados autofirmados creados por Apigee con el balanceador de carga interno de Apigee, y no puedes cambiarlos. Consulta Llamar a un proxy de API con acceso solo para uso interno.
• Opción sin TLS: si no necesitas la finalización de TLS, puedes invocar el proxy de API omitiendo la validación del certificado TLS. Por ejemplo, la opción -k de la herramienta de línea de comandos curl inhabilita la verificación de certificados, pero el protocolo TLS sigue activo durante la conexión. Ten en cuenta que no se admite el acceso al ingreso de Apigee a través de HTTP sin cifrar en el puerto 80, al igual que en Apigee Hybrid. Consulta Llamar a un proxy de API con acceso solo para uso interno.

Enrutamiento externo (MIG)

En esta sección se describe cómo configurar el enrutamiento para permitir el acceso externo a los proxies de API mediante un grupo de instancias gestionado (MIG) para enviar tráfico de API desde el servicio backend de un balanceador de carga global a Apigee. Debes hacerlo antes de poder enviar una solicitud desde un cliente externo a tu instancia de tiempo de ejecución de Apigee.

Permisos que se necesitan para completar esta tarea

Puedes asignar al aprovisionador de Apigee un rol predefinido que incluya los permisos necesarios para completar esta tarea o conceder permisos más específicos para proporcionar los privilegios mínimos necesarios. Consulta Roles predefinidos y Permisos de enrutamiento de acceso.

Nota: En una configuración multirregional, debes seguir los pasos de la línea de comandos que se describen en este artículo. La interfaz de aprovisionamiento solo te permite añadir una MIG al balanceador de carga global. Los MIGs no son globales, sino regionales. Por lo tanto, en el caso de las configuraciones multirregión, debes crear un MIG para cada región y añadirlos al servicio de backend del balanceador de carga global.

El proceso general es el siguiente:

Paso 8a: Habilita el acceso privado a Google en una subred de tu red de VPC
Paso 8b: Configura las variables de entorno
Paso 8c: Crea un grupo de instancias gestionado
Paso 8d: Crea un certificado y una clave SSL para el balanceador de carga
Paso 8e: Crea un balanceador de carga global
Paso 8f: Obtén una dirección IP reservada y crea reglas de firewall

En las siguientes secciones se describe cada uno de estos pasos.

Paso 8a: Habilita Acceso privado de Google en una subred de tu red de VPC

Para habilitar la función Acceso privado de Google en una subred de tu red de VPC, sigue los pasos que se indican en el artículo Habilitar Acceso privado de Google.

Nota: Si vas a configurar varias regiones, debes realizar este paso una vez por cada región.

Paso 8b: Configura las variables de entorno

Multirregional: en una configuración multirregional, se necesita un MIG independiente para cada región. Si vas a configurar varias regiones, repite los pasos 8b y 8c con cada una de ellas, sustituyendo las variables correspondientes.

En las instrucciones de esta sección se usan variables de entorno para hacer referencia a cadenas que se usan repetidamente. Te recomendamos que los definas antes de continuar:

MIG_NAME=apigee-mig-MIG_NAME   # You can choose a different name if you like
VPC_NAME=default       # If you are using a shared VPC, use the shared VPC name
VPC_SUBNET=default     # Private Google Access must be enabled for this subnet
REGION=RUNTIME_REGION        # The same region as your Apigee runtime instance
APIGEE_ENDPOINT=APIGEE_INSTANCE_IP     # See the tip below for details on getting this IP address value

Usarás estas variables varias veces durante los procesos restantes. Si quieres configurar varias regiones, crea variables con valores específicos para cada una.

Nota: Para obtener la dirección IP correcta de la instancia de Apigee, usa la API Instances, como se muestra en el siguiente ejemplo:

• Sin residencia de datos:

  curl -i -X GET -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

• Residencia de datos:

  curl -i -X GET -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

Apigee responde con información sobre la instancia. Por ejemplo:

{
"instances": [
  {
    "name": "my-runtime-instance",
    "location": "us-west1",
    "host": "10.16.0.2",
    "port": "443"
  },
  ...
]
}

La dirección IP de la instancia, que puedes asignar a la variable de entorno $APIGEE_ENDPOINT, es el valor del campo host. En este ejemplo, el valor es 10.16.0.2.

En una instalación multirregional, la llamada a la API devuelve los detalles de la instancia de cada ubicación regional. En ese caso, debe crear un grupo de instancias gestionadas (MIG) independiente para cada ubicación siguiendo los pasos que se indican en la siguiente sección.

Paso 8c: Crea un grupo de instancias gestionado

Multirregional: en una configuración multirregional, se necesita un MIG independiente para cada región. Si vas a configurar varias regiones, repite los pasos 8b y 8c con cada una de ellas, sustituyendo las variables correspondientes.

En este paso, creará y configurará un grupo de instancias gestionado (MIG). En un paso posterior, añade el MIG a un servicio de backend que esté asociado a un balanceador de carga mundial. Se necesita un MIG para enviar tráfico de la API desde el servicio de backend del balanceador de carga global a Apigee.

Para crear un MIG:

1. Crea una plantilla de instancia ejecutando el siguiente comando.

   gcloud compute instance-templates create $MIG_NAME \
   --project $PROJECT_ID \
   --region $REGION \
   --network $VPC_NAME \
   --subnet $VPC_SUBNET \
   --tags=https-server,apigee-mig-proxy,gke-apigee-proxy \
   --machine-type e2-medium --image-family debian-12 \
   --image-project debian-cloud --boot-disk-size 20GB \
   --no-address \
   --metadata ENDPOINT=$APIGEE_ENDPOINT,startup-script-url=gs://apigee-5g-saas/apigee-envoy-proxy-release/latest/conf/startup-script.sh

   Como puedes ver en este comando, las máquinas son de tipo e2-medium. Ejecutan Debian 12 y tienen 20 GB de disco. La secuencia de comandos startup-script.sh configura el MIG para enrutar el tráfico entrante del balanceador de carga a la instancia de Apigee.

2. Crea un grupo de instancias gestionado ejecutando el siguiente comando:

   gcloud compute instance-groups managed create $MIG_NAME \
   --project $PROJECT_ID --base-instance-name apigee-mig \
   --size 2 --template $MIG_NAME --region $REGION

3. Configura el autoescalado del grupo ejecutando el siguiente comando:
   Nota: Un MIG regional con instancias e2-medium puede admitir un máximo de 6 Gbps. Si no es suficiente para tus necesidades de rendimiento, considera la posibilidad de aumentar el tamaño de la VM o el número de réplicas.

   gcloud compute instance-groups managed set-autoscaling $MIG_NAME \
   --project $PROJECT_ID --region $REGION --max-num-replicas 3 \
   --target-cpu-utilization 0.75 --cool-down-period 90

4. Define un puerto con nombre ejecutando el siguiente comando:

   gcloud compute instance-groups managed set-named-ports $MIG_NAME \
   --project $PROJECT_ID --region $REGION --named-ports https:443

Paso 8d: Crea un certificado y una clave SSL para el balanceador de carga

Solo tienes que crear las credenciales una vez, tanto si vas a instalar el servicio en una sola región como en varias. En un paso posterior, asociará estas credenciales al proxy HTTPS de destino del balanceador de carga.

Puedes crear las credenciales con:

• Tu propio certificado de una autoridad de certificación
• Un certificado SSL gestionado por Google
• Un certificado autofirmado (no recomendado para producción).

Para obtener más información sobre cómo crear y usar certificados SSL para el balanceador de carga de Google Cloud, consulta los artículos Certificados SSL y Información general sobre los certificados SSL.

En el siguiente ejemplo, creamos un certificado SSL gestionado por Google:

1. Crea estas variables de entorno:

   CERTIFICATE_NAME=YOUR_CERT_NAME
   DOMAIN_HOSTNAME=YOUR_DOMAIN_HOSTNAME 

   Asigna a DOMAIN_HOSTNAME un nombre de host de dominio válido que hayas registrado. En un paso posterior, obtendrás la dirección IP del balanceador de carga y actualizarás el registro A del dominio para que apunte a esa dirección. Por ejemplo, el nombre de host de un dominio podría tener este aspecto: foo.example.com.

2. Ejecuta el comando gcloud compute ssl-certificates create:

   gcloud compute ssl-certificates create $CERTIFICATE_NAME \
     --domains=$DOMAIN_HOSTNAME \
     --project $PROJECT_ID \
     --global

   El certificado puede tardar hasta una hora en aprovisionarse. Para comprobar el estado del aprovisionamiento, ejecuta este comando:

   gcloud compute ssl-certificates describe $CERTIFICATE_NAME \
    --global \
    --format="get(name,managed.status, managed.Status)"

   Nota: Puede crear varios registros A de DNS para los nombres de host de su grupo de entornos que apunten a la misma dirección IP del balanceador de carga.

Paso 8e: Crea un balanceador de carga global

1. Crea una comprobación del estado:

   gcloud compute health-checks create https HEALTH_CHECK_NAME \
   --project $PROJECT_ID --port 443 --global \
   --request-path /healthz/ingress

   Usará esta comprobación de estado para asegurarse de que el servicio de backend se está ejecutando. Para configurar comprobaciones del estado más avanzadas en un proxy específico, consulta Realizar comprobaciones del estado.

   Nota: Si aparece el siguiente error al intentar crear una comprobación del estado:

   ERROR: unrecognized arguments: --global,

   Prueba a actualizar gcloud con el comando gcloud components update.

2. Crea un servicio de backend:

   gcloud compute backend-services create PROXY_BACKEND_NAME \
   --project $PROJECT_ID \
   --protocol HTTPS \
   --health-checks HEALTH_CHECK_NAME \
   --port-name https \
   --timeout 302s \
   --connection-draining-timeout 300s \
   --global

   Nota: Tal como se indica en la referencia de propiedades de Endpoint de Apigee, el tiempo de espera predeterminado del balanceador de carga interno de Apigee es de 300 segundos. Si se establece el tiempo de espera de los servicios de backend del balanceador de carga en 302 segundos, el comando de servicios de backend se completará en Apigee en caso de que haya transacciones de larga duración. Si asignas un valor inferior, como 60 segundos, es posible que el balanceador de carga agote el tiempo de espera antes de que se complete la solicitud, lo que dará lugar a respuestas 502.
3. Añade el MIG a tu servicio de backend con el siguiente comando:
   Multirregión: en una configuración multirregión, debes crear un MIG independiente para cada región y, a continuación, repetir este paso para añadir cada MIG al servicio de backend. Sustituye las variables REGION y MIG_NAME por los valores que correspondan en cada región.

   gcloud compute backend-services add-backend PROXY_BACKEND_NAME \
   --project $PROJECT_ID --instance-group $MIG_NAME \
   --instance-group-region $REGION \
   --balancing-mode UTILIZATION --max-utilization 0.8 --global

4. Crea un mapa de URLs de balanceo de carga con el siguiente comando:

   gcloud compute url-maps create MIG_PROXY_MAP_NAME \
   --project $PROJECT_ID --default-service PROXY_BACKEND_NAME

5. Crea un proxy HTTPS de destino de balanceo de carga con el siguiente comando:

   gcloud compute target-https-proxies create MIG_HTTPS_PROXY_NAME \
   --project $PROJECT_ID --url-map MIG_PROXY_MAP_NAME \
   --ssl-certificates $CERTIFICATE_NAME

Paso 8f: Obtener una dirección IP reservada y crear reglas de cortafuegos

Debes asignar una dirección IP al balanceador de carga y, a continuación, crear reglas que permitan que el balanceador de carga acceda al MIG. Solo tiene que seguir este paso una vez, tanto si va a instalar el servicio en una sola región como en varias.

1. Reserva una dirección IP para el balanceador de carga:

   gcloud compute addresses create ADDRESSES_NAME \
   --project $PROJECT_ID \
   --ip-version=IPV4 \
   --global

2. Crea una regla de reenvío global con el siguiente comando:

   gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
   --project $PROJECT_ID --address ADDRESSES_NAME --global \
   --target-https-proxy MIG_HTTPS_PROXY_NAME --ports 443

3. Para obtener la dirección IP reservada, ejecuta el siguiente comando:

   gcloud compute addresses describe ADDRESSES_NAME \
   --project $PROJECT_ID --format="get(address)" --global

4. Paso importante: Ve al sitio, al host de DNS o al ISP donde se gestionan tus registros DNS y asegúrate de que el registro DNS de tu dominio se resuelva en la dirección IP del balanceador de carga de Google Cloud. Esta dirección es el valor de IP devuelto en el último paso. Para obtener más información, consulta el artículo Actualizar los registros A y AAAA de DNS para que apunten a la dirección IP del balanceador de carga.
5. Crea una regla de cortafuegos que permita que el balanceador de carga acceda al MIG mediante el siguiente comando:

   gcloud compute firewall-rules create FIREWALL_RULE_NAME \
   --description "Allow incoming from GLB on TCP port 443 to Apigee Proxy" \
   --project $PROJECT_ID --network $VPC_NAME --allow=tcp:443 \
   --source-ranges=130.211.0.0/22,35.191.0.0/16 --target-tags=gke-apigee-proxy

   Ten en cuenta que los intervalos de direcciones IP 130.211.0.0/22 y 35.191.0.0/16 son los intervalos de direcciones IP de origen de Google Load Balancing. Esta regla de cortafuegos permite que Google Cloud Load Balancing haga solicitudes de comprobación del estado a la MIG.

El aprovisionamiento de Apigee se ha completado. Ve a Desplegar un proxy de ejemplo.

Rutas internas (PSC)

En esta sección se explica cómo permitir solo el acceso interno a tus proxies de API desde cualquiera de tus proyectos de Google Cloud mediante Private Service Connect (PSC).

Tienes dos opciones para configurar el acceso interno con PSC:

• Punto final de servicio: las solicitudes pasan por un punto final de servicio a un único punto de vinculación, denominado vinculación de servicio.
• Balanceador de carga regional interno: las solicitudes pasan por un balanceador de carga HTTP(S) interno regional. Consulta también Balanceo de carga global y regional.

Selecciona la pestaña correspondiente a tu configuración y sigue los pasos:

Endpoint de servicio

Permisos que se necesitan para completar esta tarea

Puedes asignar al aprovisionador de Apigee un rol predefinido que incluya los permisos necesarios para completar esta tarea o conceder permisos más específicos para proporcionar los privilegios mínimos necesarios. Consulta Roles predefinidos y Permisos de enrutamiento de acceso.

Crear un endpoint de servicio de PSC para la vinculación de servicio

1. Obtén el adjunto de servicio de la instancia que has creado anteriormente:

   Sin residencia de datos

   curl -i -X GET -H "Authorization: Bearer $AUTH" \
   "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

   Residencia de datos

   curl -i -X GET -H "Authorization: Bearer $AUTH" \
   "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

   En el siguiente ejemplo de salida, el valor de serviceAttachment se muestra en negrita:

   {
     "instances": [
       {
         "name": "us-west1",
         "location": "us-west1",
         "host": "10.82.192.2",
         "port": "443",
         "createdAt": "1645731488019",
         "lastModifiedAt": "1646504754219",
         "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
         "state": "ACTIVE",
         "peeringCidrRange": "SLASH_22",
         "runtimeVersion": "1-7-0-20220228-190814",
         "ipRange": "10.82.192.0/22,10.82.196.0/28",
         "consumerAcceptList": [
           "875609189304"
         ],
         "serviceAttachment": "projects/bfac74a67a320c43a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw1"
       }
     ]
   }

   Nota: El ID del proyecto que has usado para crear tu organización de Apigee siempre aparece en la lista consumerAcceptList. En el ejemplo de salida que se muestra arriba, es el único proyecto de la lista.
2. Crea un endpoint de servicio de PSC que apunte a la vinculación de servicio que has obtenido del cuerpo de respuesta de la instancia en el paso anterior, tal como se explica en Crear un endpoint de Private Service Connect.
3. Para probar la configuración, ve a Llamar a un proxy de API con acceso solo para uso interno.

Balanceador de carga regional interno

Permisos que se necesitan para completar esta tarea

Puedes asignar al aprovisionador de Apigee un rol predefinido que incluya los permisos necesarios para completar esta tarea o conceder permisos más específicos para proporcionar los privilegios mínimos necesarios. Consulta Roles predefinidos y Permisos de enrutamiento de acceso.

Restricciones: ten en cuenta las siguientes restricciones para configurar la PSC:

• El balanceador de carga HTTP(S) externo global (clásico) no es compatible con esta configuración.
• Para la conmutación por error con varios NEGs de PSC, no se admiten las comprobaciones de estado activas. En su lugar, usa la detección de anomalías.
• Se aplican límites al número de proyectos de Google Cloud que pueden conectarse a una instancia de Apigee a través de PSC, así como al número de conexiones NEG de PSC que puedes tener por proyecto. Para obtener más información, consulta la sección Límites de Private Service Connect (PSC).
• Si se elimina un proyecto de Google Cloud de consumerAcceptList, los NEGs de PSC que haya en ese proyecto seguirán funcionando. Sin embargo, se rechazarán los nuevos NEGs. Debes eliminar los NEGs existentes si quitas sus proyectos asociados de consumerAcceptList. También puedes volver a crear la instancia de Apigee, lo que recreará el adjunto de servicio en el proyecto de Apigee.

Paso 7a: Configura las variables de entorno

En las instrucciones de esta sección se usan variables de entorno para hacer referencia a cadenas que se usan repetidamente. Asegúrate de haber definido las variables en Definir variables de entorno.

Además, define las siguientes variables de entorno:

Nota: Guarda tus variables de entorno en un archivo de texto para poder restaurarlas fácilmente si es necesario.

NEG_NAME=YOUR_NEG_NAME
NETWORK_NAME=YOUR_NETWORK_NAME
SUBNET_NAME=YOUR_SUBNET_NAME
TARGET_SERVICE=TARGET_SERVICE_ATTACHMENT

Donde:

• NEG_NAME: nombre del grupo de endpoints de red.
• NETWORK_NAME: (opcional) nombre de la red en la que se crea el NEG. Si omite este parámetro, se usará la red del proyecto default.
• SUBNET_NAME nombre de la subred que se usa para la conectividad privada con el productor. El tamaño de la subred puede ser pequeño: el NEG de PSC solo necesita una IP de la subred. En Apigee, solo se necesita un NEG de PSC por región. Las máquinas virtuales u otras entidades pueden compartir y usar la subred. Si no se especifica ninguna subred, los endpoints de red pueden pertenecer a cualquier subred de la región en la que se cree el grupo de endpoints de red.
  Nota: Si especifica el parámetro --network,también debe especificar --subnet.
• TARGET_SERVICE: el adjunto de servicio al que quieres conectarte. Por ejemplo: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7
Nota: El TARGET_SERVICE se obtiene en este paso.

Paso 7b: Crea una subred de solo proxy

Nota: Esta operación solo se puede realizar una vez. Esta subred de solo proxy solo es necesaria una vez para cualquier balanceador de carga regional basado en Envoy. Consulta también Subredes de solo proxy para balanceadores de carga basados en Envoy.

gcloud compute networks subnets create testproxyonlysubnet \
--purpose=REGIONAL_MANAGED_PROXY --role=ACTIVE --region=$RUNTIME_REGION --network=$NETWORK_NAME \
--range=100.0.0.0/24 --project=$PROJECT_ID

Paso 7c: Crea un grupo de endpoints de red (NEG)

1. Obtén el adjunto de servicio de la instancia que has creado anteriormente:

   Sin residencia de datos

   curl -i -X GET -H "Authorization: Bearer $AUTH" \
   "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

   Residencia de datos

   curl -i -X GET -H "Authorization: Bearer $AUTH" \
   "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

   En el siguiente ejemplo de salida, el valor serviceAttachment se muestra en negrita:

   {
   "instances": [
     {
       "name": "us-west1",
       "location": "us-west1",
       "host": "10.82.192.2",
       "port": "443",
       "createdAt": "1645731488019",
       "lastModifiedAt": "1646504754219",
       "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
       "state": "ACTIVE",
       "peeringCidrRange": "SLASH_22",
       "runtimeVersion": "1-7-0-20220228-190814",
       "ipRange": "10.82.192.0/22,10.82.196.0/28",
       "consumerAcceptList": [
         "875609189304"
       ],
     "serviceAttachment": "projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7"
     }
   ]
   }

   Nota: El ID del proyecto que has usado para crear tu organización de Apigee siempre aparece en la lista consumerAcceptList. En el ejemplo de salida que se muestra arriba, es el único proyecto de la lista.

2. Crea un NEG de Private Service Connect que apunte a la vinculación de servicio que has obtenido del cuerpo de la respuesta de la instancia en el paso anterior.

   Nota: El siguiente comando especifica explícitamente la red y la subred que se usarán al crear el NEG. Si no se especifican estos valores, se usa la red predeterminada. Si se ha eliminado la red predeterminada y no se especifican la red ni la subred, el comando fallará.

   gcloud compute network-endpoint-groups create $NEG_NAME \
   --network-endpoint-type=private-service-connect \
   --psc-target-service=$TARGET_SERVICE \
   --region=$RUNTIME_LOCATION \
   --project=$PROJECT_ID
   --network=$NETWORK_NAME
   --subnet=$SUBNET_NAME
   

   Dónde

   • $PROJECT_ID puede ser el proyecto de Cloud que ya esté asociado a tu organización de Apigee o un proyecto de Cloud incluido en consumerAcceptlist cuando se creó la instancia de tiempo de ejecución de Apigee.

Paso 7d: Configura el balanceador de carga interno regional

1. Reserva una dirección IPv4 interna para el balanceador de carga.

   gcloud compute addresses create ADDRESS_NAME \
   --ip-version=IPV4 --subnet=$SUBNET_NAME \
   --region=$RUNTIME_LOCATION --project=$PROJECT_ID

   Sustituye ADDRESS_NAME por el nombre del recurso de dirección IP.

   Ejecuta este comando para ver la dirección IP reservada:

   gcloud compute addresses describe ADDRESS_NAME \
   --format="get(address)" --region=$RUNTIME_LOCATION --project=$PROJECT_ID

2. Crea un servicio de backend para el NEG.

   gcloud compute backend-services create BACKEND_SERVICE_NAME \
   --load-balancing-scheme=INTERNAL_MANAGED \
   --protocol=HTTPS \
   --region=$RUNTIME_LOCATION \
   --project=$PROJECT_ID

Sustituye BACKEND_SERVICE_NAME por el nombre del servicio de backend.

3. Añade el NEG al servicio de backend:

   gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
   --network-endpoint-group=$NEG_NAME \
   --region=$RUNTIME_LOCATION \
   --project=$PROJECT_ID

   Haz los cambios siguientes:

   • NEG_NAME: el nombre del grupo de endpoints de red.
   • BACKEND_SERVICE_NAME con el nombre del servicio de backend.

4. Para crear un balanceador de carga HTTPS, debes tener un recurso de certificado SSL que usar en el proxy HTTPS de destino.

   Usa este comando para crear un recurso de certificado SSL autogestionado. Para crear un certificado SSL autogestionado, necesitas un archivo de clave privada local y un archivo de certificado local. Si necesitas crear estos archivos, consulta el paso 1 para usar certificados SSL autogestionados.

   Nota: El balanceador de carga regional interno no admite certificados gestionados por Google.

   gcloud compute ssl-certificates create CERTIFICATE \
   --certificate LB_CERT \
   --private-key LB_PRIVATE_KEY
   --region=$RUNTIME_LOCATION --project=$PROJECT_ID

   Haz los cambios siguientes:

   • CERTIFICATE: un nombre para el certificado.
   • LB_CERT: la ruta al archivo de certificado con formato PEM de tu certificado autogestionado.
   • LB_PRIVATE_KEY: la ruta al archivo de clave privada con formato PEM de tu certificado autogestionado.

5. Crea un mapa de URLs para el balanceador de carga.

   Un mapa de URLs debe hacer referencia a un servicio de backend predeterminado. Define como predeterminado el servicio de backend que acabas de crear.

   gcloud compute url-maps create URL_MAP_NAME \
   --default-service=DEFAULT_BACKEND_SERVICE_NAME \
   --region=$RUNTIME_REGION \
   --project=$PROJECT_ID

   Haz los cambios siguientes:

   • URL_MAP_NAME: nombre del mapa de URLs.
   • DEFAULT_BACKEND_SERVICE_NAME: el nombre del servicio de backend predeterminado del balanceador de carga. El valor predeterminado se usa cuando ninguna regla de host coincide con el nombre de host solicitado.

6. Usa el recurso de certificado SSL para crear un proxy HTTPS de destino.

   gcloud compute target-https-proxies create PROXY_NAME \
   --url-map=URL_MAP_NAME \
   --ssl-certificates=CERTIFICATE \
   --region=$RUNTIME_LOCATION --project=$PROJECT_ID

   Haz los cambios siguientes:

   • PROXY_NAME: nombre del proxy HTTPS de destino.
   • URL_MAP_NAME: nombre del mapa de URLs.
   • CERTIFICATE: el nombre del recurso de certificado.
7. Crea la regla de reenvío.

   gcloud compute forwarding-rules create FWD_RULE \
   --load-balancing-scheme=INTERNAL_MANAGED \
   --address=ADDRESS_NAME \
   --target-https-proxy=PROXY_NAME \
   --ports=443 \
   --target-https-proxy-region=$RUNTIME_REGION \
   --region=$RUNTIME_REGION \
   --project=$PROJECT_ID \
   --network=$NETWORK_NAME \
   --subnet=$SUBNET_NAME
   

   Haz los cambios siguientes:

   • FWD_RULE: el nombre de la regla de reenvío.
   • ADDRESS_NAME: el recurso de dirección IP que has reservado para usarlo en la regla de reenvío.
   • PROXY_NAME: nombre del proxy HTTPS de destino.
   • NETWORK_NAME: (opcional) nombre de la red en la que se crea el NEG. Si omite este parámetro, se usará la red del proyecto default.
   • SUBNET_NAME nombre de la subred que se usa para la conectividad privada con el productor.
     Nota: Si especifica el parámetro --network,también debe especificar --subnet.
8. El aprovisionamiento de Apigee se ha completado. Ve a Desplegar un proxy de ejemplo.

Enrutamiento externo (PSC)

En esta sección se describe cómo configurar el enrutamiento externo mediante Private Service Connect (PSC) para permitir la comunicación entre Apigee y las VPCs que controlas. Debes hacerlo antes de poder enviar una solicitud desde un cliente externo a tu instancia de tiempo de ejecución de Apigee.

Permisos que se necesitan para completar esta tarea

Puedes asignar al aprovisionador de Apigee un rol predefinido que incluya los permisos necesarios para completar esta tarea o conceder permisos más específicos para proporcionar los privilegios mínimos necesarios. Consulta Roles predefinidos y Permisos de enrutamiento de acceso.

Restricciones: ten en cuenta las siguientes restricciones para la configuración de PSC:

• El balanceador de carga HTTP(S) externo global (clásico) no es compatible con esta configuración.
• Para la conmutación por error con varios NEGs de PSC, no se admiten las comprobaciones de estado activas. En su lugar, usa la detección de anomalías.
• Se aplican límites al número de proyectos de Google Cloud que pueden conectarse a una instancia de Apigee a través de PSC, así como al número de conexiones NEG de PSC que puedes tener por proyecto. Para obtener más información, consulta la sección Límites de Private Service Connect (PSC).
• Si se elimina un proyecto de Google Cloud de consumerAcceptList, los NEGs de PSC que haya en ese proyecto seguirán funcionando. Sin embargo, se rechazarán los nuevos NEGs. Debes eliminar los NEGs existentes si quitas sus proyectos asociados de consumerAcceptList. También puedes volver a crear la instancia de Apigee, lo que recreará el adjunto de servicio en el proyecto de Apigee.

Paso 7b: Crea un NEG y configura el balanceador de carga

Puedes crear un balanceador de carga global o regional.

Balanceador de carga externo global

Configura un balanceador de carga HTTP(S) externo global (con el esquema de balanceo de carga definido como EXTERNAL_MANAGED).

Aunque el NEG de Private Service Connect es regional, el resto de los componentes de balanceo de carga de esta configuración son globales.

1. Asegúrate de haber definido las variables de entorno en Definir variables de entorno.
2. Obtén el adjunto de servicio de la instancia que has creado anteriormente:

   Sin residencia de datos

   curl -i -X GET -H "Authorization: Bearer $AUTH" \
       "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

   Residencia de datos

   curl -i -X GET -H "Authorization: Bearer $AUTH" \
       "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

   En el siguiente ejemplo de salida, el valor serviceAttachment se muestra en negrita:

   {
     "instances": [
       {
         "name": "us-west1",
         "location": "us-west1",
         "host": "10.82.192.2",
         "port": "443",
         "createdAt": "1645731488019",
         "lastModifiedAt": "1646504754219",
         "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
         "state": "ACTIVE",
         "peeringCidrRange": "SLASH_22",
         "runtimeVersion": "1-7-0-20220228-190814",
         "ipRange": "10.82.192.0/22,10.82.196.0/28",
         "consumerAcceptList": [
           "875609189304"
         ],
         "serviceAttachment": "projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7"
       }
     ]
   }

   Nota: El ID del proyecto que has usado para crear tu organización de Apigee siempre aparece en la lista consumerAcceptList. En el ejemplo de salida que se muestra arriba, es el único proyecto de la lista.

3. Crea un NEG de Private Service Connect que apunte a la vinculación de servicio que has obtenido del cuerpo de la respuesta de la instancia en el paso anterior.

     gcloud compute network-endpoint-groups create NEG_NAME \
       --network-endpoint-type=private-service-connect \
       --psc-target-service=TARGET_SERVICE \
       --region=$RUNTIME_LOCATION \
       --network=NETWORK_NAME \
       --subnet=SUBNET_NAME \
       --project=$PROJECT_ID
   

   Haz los cambios siguientes:

   • NEG_NAME: nombre del grupo de endpoints de red.
   • TARGET_SERVICE: el archivo adjunto de servicio al que quieras conectarte. Usa el valor de adjunto de servicio devuelto por el comando anterior. Por ejemplo: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7
   • NETWORK_NAME: (Opcional) Nombre de la red en la que se crea el NEG. Si omite este parámetro, se usará la red del proyecto default.
   • SUBNET_NAME: nombre de la subred usada para la conectividad privada con el productor. El tamaño de la subred puede ser pequeño: el NEG de PSC solo necesita una IP de la subred. En Apigee, solo se necesita un NEG de PSC por región. Las máquinas virtuales u otras entidades pueden compartir y usar la subred. Si no se especifica ninguna subred, los endpoints de red pueden pertenecer a cualquier subred de la región en la que se cree el grupo de endpoints de red.
     Nota: Si especifica el parámetro --network,también debe especificar --subnet.
   • $PROJECT_ID: el proyecto de Cloud que ya está asociado a tu organización de Apigee o un proyecto de Cloud incluido en consumerAcceptlist cuando se creó la instancia de tiempo de ejecución de Apigee. Si aún no lo has hecho, crea una variable de entorno para almacenar el ID del proyecto, ya que se usa en la mayoría de los comandos siguientes.
4. Reserva una dirección IPv4 externa global para el balanceador de carga.

   gcloud compute addresses create ADDRESS_NAME \
       --ip-version=IPV4 --global --project=$PROJECT_ID

   Sustituye ADDRESS_NAME por el nombre del recurso de dirección IP.

   Ejecuta este comando para ver la dirección IP reservada:

   gcloud compute addresses describe ADDRESS_NAME \
       --format="get(address)" --global --project=$PROJECT_ID

5. Crea un servicio de backend para el NEG.

   gcloud compute backend-services create BACKEND_SERVICE_NAME \
       --load-balancing-scheme=EXTERNAL_MANAGED \
       --protocol=HTTPS \
       --global --project=$PROJECT_ID

Sustituye BACKEND_SERVICE_NAME por el nombre del servicio de backend.

6. Añade el NEG al servicio de backend.

   gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
       --network-endpoint-group=NEG_NAME \
       --network-endpoint-group-region=REGION \
       --global --project=$PROJECT_ID

   Haz los cambios siguientes:

   • BACKEND_SERVICE_NAME: el nombre del servicio de backend.
   • NEG_NAME: el nombre del grupo de endpoints de red.
   • REGION: la región del grupo de puntos finales de red.

7. Crea un mapa de URLs para el balanceador de carga.

   Un mapa de URLs debe hacer referencia a un servicio de backend predeterminado. Define como predeterminado el servicio de backend que acabas de crear.

   gcloud compute url-maps create URL_MAP_NAME \
       --default-service=DEFAULT_BACKEND_SERVICE_NAME \
       --global --project=$PROJECT_ID

   Haz los cambios siguientes:

   • URL_MAP_NAME: nombre del mapa de URLs.
   • DEFAULT_BACKEND_SERVICE_NAME: el nombre del servicio de backend predeterminado del balanceador de carga. El valor predeterminado se usa cuando ninguna regla de host coincide con el nombre de host solicitado.

8. Crea el proxy HTTPS de destino.

   Para crear un balanceador de carga HTTPS, debes tener un recurso de certificado SSL que usar en el proxy HTTPS de destino. Puedes crear un recurso de certificado SSL con un certificado SSL gestionado por Google o con un certificado SSL autogestionado. Te recomendamos que uses certificados gestionados por Google, ya que Google Cloud los obtiene, gestiona y renueva automáticamente.

   Para crear un certificado gestionado por Google, debes tener un dominio.

   Usa este comando para crear un recurso de certificado SSL gestionado por Google:

   gcloud compute ssl-certificates create CERTIFICATE \
       --domains DOMAIN --project=$PROJECT_ID

   Haz los cambios siguientes:

   • CERTIFICATE: un nombre para el certificado.
   • DOMAIN: el nombre de dominio de tu balanceador de carga.

   Usa este comando para crear un recurso de certificado SSL autogestionado. Para crear un certificado SSL autogestionado, necesitas un archivo de clave privada local y un archivo de certificado local. Si necesitas crear estos archivos, consulta el paso 1 para usar certificados SSL autogestionados.

   gcloud compute ssl-certificates create CERTIFICATE \
       --certificate LB_CERT \
       --private-key LB_PRIVATE_KEY --project=$PROJECT_ID

   Haz los cambios siguientes:

   • CERTIFICATE: un nombre para el certificado.
   • LB_CERT: la ruta al archivo de certificado con formato PEM de tu certificado autogestionado.
   • LB_PRIVATE_KEY: la ruta al archivo de clave privada con formato PEM de tu certificado autogestionado.

   Usa el recurso de certificado SSL para crear un proxy HTTPS de destino.

   gcloud compute target-https-proxies create PROXY_NAME \
       --url-map=URL_MAP_NAME \
       --ssl-certificates=CERTIFICATE --project=$PROJECT_ID

   Haz los cambios siguientes:

   • PROXY_NAME: nombre del proxy HTTPS de destino.
   • URL_MAP_NAME: nombre del mapa de URLs.
   • CERTIFICATE: el nombre del recurso de certificado.
9. Crea la regla de reenvío.

   gcloud compute forwarding-rules create FWD_RULE \
       --load-balancing-scheme=EXTERNAL_MANAGED \
       --network-tier=PREMIUM \
       --address=ADDRESS_NAME \
       --target-https-proxy=PROXY_NAME \
       --ports=443 \
       --global --project=$PROJECT_ID

   Haz los cambios siguientes:

   • FWD_RULE: el nombre de la regla de reenvío.
   • ADDRESS_NAME: el recurso de dirección IP que has reservado para usarlo en la regla de reenvío.
   • PROXY_NAME: nombre del proxy HTTPS de destino.

Balanceador de carga externo regional

Configura un balanceador de carga HTTP(S) externo regional. Consulta también la descripción general de los balanceadores de carga HTTP y HTTPS externos.

1. Asegúrate de haber definido las variables en Definir variables de entorno.
2. Crea una subred de solo proxy:
   Nota: Esta operación solo se puede realizar una vez. Esta subred de solo proxy solo se requiere una vez por proyecto de Google Cloud para cualquier balanceador de carga regional basado en Envoy. Consulta también Subredes de solo proxy para balanceadores de carga basados en Envoy.

   gcloud compute networks subnets create SUBNET_NAME \
         --purpose=REGIONAL_MANAGED_PROXY --role=ACTIVE \
         --region=$RUNTIME_LOCATION --network=NETWORK_NAME \
         --range=100.0.0.0/24 --project=$PROJECT_ID

   Haz los cambios siguientes:

   • SUBNET_NAME: el nombre de la subred.
   • (Opcional) NETWORK_NAME: nombre de la red en la que se crea la subred. Si omite este parámetro, se usará la red del proyecto predeterminada.
3. Obtén el adjunto de servicio de la instancia que has creado anteriormente:

   Sin residencia de datos

   curl -i -X GET -H "Authorization: Bearer $AUTH" \
       "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

   Residencia de datos

   curl -i -X GET -H "Authorization: Bearer $AUTH" \
       "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

   En el siguiente ejemplo de salida, el valor serviceAttachment se muestra en negrita:

   {
     "instances": [
       {
         "name": "us-west1",
         "location": "us-west1",
         "host": "10.82.192.2",
         "port": "443",
         "createdAt": "1645731488019",
         "lastModifiedAt": "1646504754219",
         "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
         "state": "ACTIVE",
         "peeringCidrRange": "SLASH_22",
         "runtimeVersion": "1-7-0-20220228-190814",
         "ipRange": "10.82.192.0/22,10.82.196.0/28",
         "consumerAcceptList": [
           "875609189304"
         ],
         "serviceAttachment": "projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7"
       }
     ]
   }

   Nota: El ID del proyecto que has usado para crear tu organización de Apigee siempre aparece en la lista consumerAcceptList. En el ejemplo de salida que se muestra arriba, es el único proyecto de la lista.
4. Crea un grupo de endpoints de red.

   gcloud compute network-endpoint-groups create NEG_NAME \
       --network-endpoint-type=private-service-connect \
       --psc-target-service=TARGET_SERVICE \
       --region=$RUNTIME_LOCATION --project=$PROJECT_ID

   Haz los cambios siguientes:

   • NEG_NAME: el nombre del grupo de endpoints de red.
   • TARGET_SERVICE: el nombre del archivo adjunto de servicio al que quieras conectarte. Por ejemplo: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7
5. Crea un servicio de backend para el NEG.

   gcloud compute backend-services create BACKEND_SERVICE_NAME \
     --load-balancing-scheme=EXTERNAL_MANAGED \
     --protocol=HTTPS \
     --region=$RUNTIME_LOCATION  \
     --project=$PROJECT_ID

Sustituye BACKEND_SERVICE_NAME por el nombre del servicio de backend.

6. Añade el NEG al servicio de backend.

   gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
     --network-endpoint-group=NEG_NAME \
     --region=$RUNTIME_LOCATION  \
     --project=$PROJECT_ID

   Haz los cambios siguientes:

   • BACKEND_SERVICE_NAME: el nombre del servicio de backend.
   • NEG_NAME: el nombre del grupo de endpoints de red.

7. Crea un mapa de URLs para el balanceador de carga.

   Un mapa de URLs debe hacer referencia a un servicio de backend predeterminado. Define como predeterminado el servicio de backend que acabas de crear.

   gcloud compute url-maps create URL_MAP_NAME \
     --default-service=DEFAULT_BACKEND_SERVICE_NAME \
     --region=$RUNTIME_LOCATION  \
     --project=$PROJECT_ID

   Haz los cambios siguientes:

   • URL_MAP_NAME: nombre del mapa de URLs.
   • DEFAULT_BACKEND_SERVICE_NAME: el nombre del servicio de backend predeterminado del balanceador de carga. El valor predeterminado se usa cuando ninguna regla de host coincide con el nombre de host solicitado.

8. Crea el proxy HTTPS de destino.

   Para crear un balanceador de carga HTTPS, debes tener un recurso de certificado SSL que usar en el proxy HTTPS de destino.

   Usa este comando para crear un recurso de certificado SSL autogestionado. Para crear un certificado SSL autogestionado, necesitas un archivo de clave privada local y un archivo de certificado local. Si necesitas crear estos archivos, consulta el paso 1 para usar certificados SSL autogestionados.

   Nota: El balanceador de carga regional interno no admite certificados gestionados por Google.

   gcloud compute ssl-certificates create CERTIFICATE \
     --certificate LB_CERT \
     --private-key LB_PRIVATE_KEY --region=$RUNTIME_LOCATION \
     --project=$PROJECT_ID

   Haz los cambios siguientes:

   • CERTIFICATE: un nombre para el certificado.
   • LB_CERT: la ruta al archivo de certificado con formato PEM de tu certificado autogestionado.
   • LB_PRIVATE_KEY: la ruta al archivo de clave privada con formato PEM de tu certificado autogestionado.

   Usa el recurso de certificado SSL para crear un proxy HTTPS de destino.

   gcloud compute target-https-proxies create PROXY_NAME \
     --url-map=URL_MAP_NAME --region=$RUNTIME_LOCATION \
     --ssl-certificates=CERTIFICATE --project=$PROJECT_ID

   Haz los cambios siguientes:

   • PROXY_NAME: nombre del proxy HTTPS de destino.
   • URL_MAP_NAME: nombre del mapa de URLs.
   • CERTIFICATE: el nombre del recurso de certificado.
9. Reserva una dirección externa regional para el balanceador de carga. Ten en cuenta que el nivel de red debe ser STANDARD.

   gcloud compute addresses create ADDRESS_NAME \
         --region=$RUNTIME_LOCATION --network-tier=STANDARD \
         --project=$PROJECT_ID

   Sustituye ADDRESS_NAME por el nombre del recurso de dirección IP.

   Ejecuta este comando para ver la dirección IP reservada:

   gcloud compute addresses describe ADDRESS_NAME \
         --format="get(address)" --region=$RUNTIME_LOCATION \
         --project=$PROJECT_ID

10. Crea la regla de reenvío.

    gcloud compute forwarding-rules create FWD_RULE \
      --load-balancing-scheme=EXTERNAL_MANAGED \
      --network-tier=STANDARD \
      --address=ADDRESS_NAME \
      --target-https-proxy=PROXY_NAME \
      --ports=443  --region=$RUNTIME_LOCATION \
      --target-https-proxy-region=$RUNTIME_LOCATION --project=$PROJECT_ID

    Haz los cambios siguientes:

    • FWD_RULE: el nombre de la regla de reenvío.
    • ADDRESS_NAME: el recurso de dirección IP que has reservado para usarlo en la regla de reenvío.
    • PROXY_NAME: nombre del proxy HTTPS de destino.

El aprovisionamiento de Apigee se ha completado. Ve a Desplegar un proxy de ejemplo.

Paso 9: Despliega un proxy de ejemplo

Permisos que se necesitan para completar esta tarea

Para crear y desplegar proxies, se necesita un conjunto mínimo de permisos. Si tienes el rol de administrador de la organización de Apigee, puedes completar esta tarea. Para obtener información sobre otros roles que puedes usar, consulta Roles de Apigee.

Sigue estos pasos si has completado la configuración de:

• Enrutamiento externo (MIG)
• Enrutamiento externo (PSC)
• Rutas internas (PSC)

Si has configurado el enrutamiento interno (VPC), omite estos pasos y ve a Llamar a un proxy de API con acceso solo para uso interno.

1. Descarga el proxy de ejemplo de GitHub. El objetivo del proxy es el servicio httpbin.org, que es un servicio público de solicitudes y respuestas de uso habitual.
2. Sube el paquete de proxy de la API al tiempo de ejecución mediante la API de Apigee apis:

   Sin residencia de datos

   curl -i -X POST -H "Authorization: Bearer $AUTH" \
       -H "Content-Type:multipart/form-data" \
       "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/apis?name=httpbin&action=import" \
       -F 'file=@PATH_TO_ZIP_FILE/httpbin_rev1_2020_02_02.zip'

   Residencia de datos

   curl -i -X POST -H "Authorization: Bearer $AUTH" \
       -H "Content-Type:multipart/form-data" \
       "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/apis?name=httpbin&action=import" \
       -F 'file=@PATH_TO_ZIP_FILE/httpbin_rev1_2020_02_02.zip'

   Donde PATH_TO_ZIP_FILE es la ruta al directorio que contiene el archivo ZIP descargado.

3. Despliega el proxy de API en el entorno que has creado anteriormente:

   Sin residencia de datos

   curl -i -H "Authorization: Bearer $AUTH" -X POST \
       "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/revisions/1/deployments"

   Residencia de datos

   curl -i -H "Authorization: Bearer $AUTH" -X POST \
       "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/revisions/1/deployments"

4. Confirma que el despliegue se ha completado correctamente con esta llamada a la API:

   Sin residencia de datos

   curl -i -H "Authorization: Bearer $AUTH" \
       "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/revisions/1/deployments"

   Residencia de datos

   curl -i -H "Authorization: Bearer $AUTH" \
       "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/revisions/1/deployments"

5. Llama al proxy de API:

   Envía una solicitud al proxy de API desde cualquier máquina con conexión de red ejecutando el siguiente comando:

   curl -i -H "Host: ENV_GROUP_HOSTNAME" \
       "https://ENV_GROUP_HOSTNAME/httpbin/headers"

   Si es necesario, puedes usar esta API para obtener el valor ENV_GROUP_HOSTNAME:

   Sin residencia de datos

   curl -i -H "Authorization: Bearer $AUTH" \
       "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups"

   Residencia de datos

   curl -i -H "Authorization: Bearer $AUTH" \
       "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups"

   Si aparece un error como este: CONNECT_CR_SRVR_HELLO:sslv3 alert handshake failure, comprueba que el certificado SSL que has creado anteriormente se haya aprovisionado. Usa este comando para comprobar el estado del aprovisionamiento. Cuando se aprovisiona el certificado, su estado es ACTIVE.

   gcloud compute ssl-certificates describe CERTIFICATE \
       --global \
       --format="get(name,managed.status, managed.Status)"

   Si la operación se realiza correctamente, el proxy de API de ejemplo devuelve una respuesta similar a esta:

   {
       "headers": {
         "Accept": "*/*",
         "Grpc-Trace-Bin": "AAD/8WC/I4AUSrMEch0E9yj+AYck1x9afwckAgA",
         "Host": "httpbin.org",
         "Traceparent": "00-fff160bf2380144ab304721d04f728fe-8724d71f5a7f0724-00",
         "User-Agent": "curl/7.77.0",
         "X-Amzn-Trace-Id": "Root=1-61d785ef-7613aa8a7fde7a910441fab9",
         "X-B3-Sampled": "0",
         "X-B3-Spanid": "8724d71f5a7f0724",
         "X-B3-Traceid": "fff160bf2380144ab304721d04f728fe",
         "X-Cloud-Trace-Context": "fff160bf2380144ab304721d04f728fe/9738144823944087332;o=0",
         "X-Envoy-Attempt-Count": "1"
       }
   }

Para obtener más información sobre cómo implementar proxies, incluida información adicional para solucionar problemas, consulta Implementar un proxy de API.