Aprovisiona una organización pagada con intercambio de tráfico entre 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 intercambio de tráfico entre VPC. Estos pasos se aplican a los modelos de precios de suscripción y de pago por uso para las organizaciones pagadas con o sin la residencia de datos habilitada.

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. Google Cloud CLI administra la autenticación, la configuración local, el flujo de trabajo de los desarrolladores y las interacciones con las APIs de Google Cloud.
Paso 2: Habilita las API: Apigee requiere que habilites varias APIs de Google Cloud.
Paso 3: Crea la identidad del servicio de Apigee: Las bibliotecas cliente de Google Cloud usan esta cuenta de servicio. para autenticarse con las APIs de Google Cloud.
Paso 4: Configura herramientas de redes de servicio: las herramientas de redes de servicio automatizan la configuración de la conectividad privada (con el intercambio de tráfico entre redes de VPC) entre tu red y Apigee.
Paso 5: Crea una organización: Una organización de Apigee (a veces conocida como org) es el contenedor de nivel superior en Apigee. Incluye todos los entornos y grupos de entornos, usuarios, proxies de API y recursos relacionados.
Paso 6: Crea una instancia del entorno de ejecución: Una instancia, o entorno de ejecución, es donde se almacenan tu proyecto y los servicios relacionados. Le proporciona a tus servicios el extremo para el usuario.
Paso 7: Crea un entorno: Un proxy de API debe implementarse en un entorno y agregarse a un grupo de entornos, antes de que las APIs que expone sean accesibles a través de la red.
Paso 8: Configura el enrutamiento: Permite el acceso externo o el acceso solo interno a la API.
Paso 9: Implementa un proxy de muestra: Prueba el aprovisionamiento mediante la implementación y llamada de un proxy de API.

Paso 1: Definir las variables de entorno

Configura gcloud y define variables de entorno para usarlas en pasos posteriores:

Asegúrate de haber completado los requisitos de configuración que se enumeran en Antes de comenzar.
Debes tener instalado el SDK de Cloud. Si necesitas instalarlo, consulta Instala el SDK de Cloud.
Inicializa el SDK de Cloud, como se describe enInicializa gcloud CLI, o asegúrate de que el proyecto de Google Cloud que creaste en Requisitos previos es el proyecto predeterminado para gcloud.
Define las siguientes variables de entorno en tu terminal de comando. Selecciona la pestaña que corresponda al tipo de organización que necesitas: Sin residencia de datos o con Residencia de datos
Sugerencia: Guarda las variables de entorno en un archivo de texto para que puedas restablecerlas con facilidad 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 aprovisionas una organización de Apigee nueva dentro de un proyecto de Google Cloud con una restricción de ubicación de recursos aplicada en una política de la organización, confirma que la restricción de ubicación esté establecida en global. Debido a que el plano de control de Apigee es una entidad global de forma predeterminada, el aprovisionamiento fallará si se aplica una restricción distinta de global. Para obtener más información, consulta Introducción a la residencia de datos.

Aquí:
- AUTH define el encabezado Authentication con un token del portador. Usarás este encabezado cuando llames a las APIs de Apigee. Ten en cuenta que el token vence después de un período y, cuando lo hace, 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 creaste como parte de los requisitos previos.
- PROJECT_NUMBER es el número de proyecto de Cloud que creaste como parte de los requisitos previos.
- RUNTIME_LOCATION es la ubicación física en la que se encuentra la instancia de Apigee que crearás más tarde. Para obtener una lista de las ubicaciones disponibles del entorno de ejecución, consulta Ubicaciones de Apigee.
  
  Nota: Para RUNTIME_LOCATION, asegúrate de usar un nombre de región y no un nombre de zona. Por ejemplo, us-west1 es un nombre de región, mientras que us-west1-a es una zona en la región. Consulta también Identifica una región o zona.
- ANALYTICS_REGION es la ubicación física en la que se almacenarán los datos analíticos de Apigee. Para obtener una lista de las regiones disponibles de las estadísticas de la API de Apigee, consulta Ubicaciones de Apigee.
  
  Tanto RUNTIME_LOCATION como ANALYTICS_REGION pueden ser de la misma región, pero no es necesario que sean iguales.
- BILLING_TYPE es el tipo de facturación para la organización que creas. Estos son los valores válidos:
  - PAYG para organizaciones de pago por uso.
  - SUBSCRIPTION para las organizaciones de suscripción.
Residencia de los 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 usas la residencia de datos, la ubicación del plano de control es la región que lo contiene. Todas las demás regiones deben estar dentro de la ubicación del plano de control. Cuando la ubicación del plano de control es us, la región de datos del consumidor y la ubicación del entorno de ejecución también deben estar dentro de us. Por ejemplo, se acepta us-west1, en el que no se incluye europe-west1.

Aquí:
- AUTH define el encabezado Authentication con un token del portador. Usarás este encabezado cuando llames a las APIs de Apigee. Ten en cuenta que el token vence después de un período y, cuando lo hace, 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 creaste como parte de los requisitos previos.
- PROJECT_NUMBER es el número de proyecto de Cloud que creaste como parte de los requisitos previos.
- RUNTIME_LOCATION es la ubicación física en la que se encuentra la instancia de Apigee que crearás más tarde. Para obtener una lista de las ubicaciones disponibles del entorno de ejecución, consulta Ubicaciones de Apigee.
  
  Nota: Para RUNTIME_LOCATION, asegúrate de usar un nombre de región y no un nombre de zona. Por ejemplo, us-west1 es un nombre de región, mientras que us-west1-a es una zona en la región. Consulta también Identifica una región o zona.
  La ubicación del entorno 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 obtener una lista de las ubicaciones disponibles del plano de control, 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 obtener una lista de las regiones de datos del consumidor disponibles, consulta Ubicaciones de Apigee.
- BILLING_TYPE es el tipo de facturación para la organización que creas. Estos son los valores válidos:
  - PAYG para organizaciones de pago por uso.
  - SUBSCRIPTION para las organizaciones de suscripción.

(Opcional) Para verificar su trabajo, repita los valores que acaba de configurar. Ten en cuenta que cuando quieras usar una variable en tus comandos, deberás colocar un signo de dólar antes de su nombre ($).

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 verse de la siguiente manera:

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

Residencia de los 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 verse de la siguiente manera:

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

Paso 2: Habilitar las API

Permisos necesarios para esta tarea

Puedes otorgar al aprovisionador de Apigee un rol predefinido que incluya los permisos necesarios para completar esta tarea, o bien otorgar permisos más detallados para proporcionar el privilegio mínimo necesario. Consulta Roles predefinidos y Permisos de habilitación de API.

Apigee requiere que habilites varias APIs de Google Cloud. Habilítalas mediante la ejecución del siguiente comando de services enable:

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

Si deseas verificar tu trabajo, usa el comando services list para mostrar todas las APIs habilitadas (opcional):
```
gcloud services list
```
En la respuesta, se muestran todos los servicios habilitados, incluidas las APIs que acabas de habilitar.

Paso 3: Crear la identidad de servicio de Apigee

Crea la identidad del servicio de Apigee:

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

Verifica que el agente se haya creado correctamente. La respuesta debe mostrar el nombre del agente en el siguiente formato: service-PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com. Por ejemplo:
```
Service identity created: service-1234567890@gcp-sa-apigee.iam.gserviceaccount.com
```

Paso 4: Configurar las herramientas de redes de servicio

En este paso, asignarás un par de rangos de direcciones IP (un rango CIDR /22 y /28) a Apigee y realizarás el intercambio de tráfico de VPC entre tu red y la red de Apigee. Cada instancia de Apigee requiere un rango de CIDR no superpuesto de /22 y /28. Se asignan direcciones IP desde este rango de CIDR al plano del entorno de ejecución de Apigee. Por lo tanto, es importante que el rango esté reservado para Apigee y que no use otras aplicaciones en la red de VPC. Para obtener más información y consideraciones importantes, consulta Información sobre los rangos de intercambio de tráfico.

Ten en cuenta que estás creando un rango de IP de red suficiente para una instancia de Apigee. Si planeas crear instancias adicionales de Apigee, debes repetir este paso para cada una. Los rangos no se pueden compartir entre instancias. Consulta también Expande Apigee a varias regiones.

Importante: Si ya tienes un rango de intercambio de tráfico y una conexión privada con servicenetworking.googleapis.com, y tu rango es tan grande como se necesita como para manejar otro rango CIDR /22 y /28, puedes omitir este paso. Apigee creará los bloques CIDR necesarios por ti. Este paso solo es necesario si aún no tienes un espacio creado que tenga margen para crear un bloque /22 y /28, o si quieres usar un /22 y /28 específico que, por el momento, no está presente.

Permisos necesarios para esta tarea

Crea estas variables de entorno:
```
RANGE_NAME=YOUR_RANGE_NAME
NETWORK_NAME=YOUR_NETWORK_NAME
```
Aquí:
- RANGE_NAME es el nombre del rango de direcciones IP que estás creando. Puedes nombrar el rango como desees. 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, no recomienda usar la red predeterminada para nada más que la prueba.
  
  Nota: Google no recomienda usar default, a menos que pruebes este proceso de configuración. No se debe usar una organización con una red predeterminada en producción.
Crea un rango de IP de red con una longitud de 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
```
En el ejemplo anterior, --addresses te permite especificar un rango de direcciones. Por ejemplo, para asignar el bloque CIDR 192.168.0.0/22, especifica 192.168.0.0 como la dirección y 22 como la longitud de prefijo. Consulta también Crea una asignación de IP.

Si no proporcionas el parámetro --addresses, gcloud selecciona un rango de direcciones disponible por ti.

Si se ejecuta de forma correcta, gcloud responde con lo siguiente:
```
Created [https://www.googleapis.com/compute/v1/projects/PROJECT_NAME/global/addresses/google-svcs].
```
Después de crear un rango de direcciones IP, las direcciones se asocian al proyecto hasta que las liberes.

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

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

Crea un rango de IP de red con una longitud de CIDR de /28. Este rango es obligatorio y Apigee lo usa para solucionar problemas y 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
```
En el ejemplo anterior, --addresses te permite especificar un rango de direcciones. Por ejemplo, para asignar el bloque CIDR 192.168.0.0/28, especifica 192.168.0.0 como la dirección y 28 como la longitud de prefijo. Consulta también Crea una asignación de IP.

Si no proporcionas el parámetro --addresses, gcloud selecciona un rango de direcciones disponible por ti.

Verifica que el rango de IP de la red se haya creado con una longitud de CIDR de /28:

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

Conecta tus servicios a la VPC 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 se ejecuta de forma correcta, gcloud responde con lo siguiente, donde OPERATION_ID es el UUID de LRO.

Operation "operations/OPERATION_ID" finished successfully.

Apigee crea una conexión entre tu VPC y los servicios de Google. En específico, Apigee conecta tu proyecto con la API de Service Networking a través del intercambio de tráfico de VPC. Apigee también asocia direcciones IP a tu proyecto.

Después de unos minutos, verifica si el intercambio de tráfico entre VPC se realizó de forma correcta:

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

Paso 5: Crear una organización

Permisos necesarios para esta tarea

Antes de crear una organización, debes crear un llavero de claves y una clave de encriptación de la base de datos del entorno de ejecución (consulta el paso 1) y, si usas la residencia de datos., llaveros de claves y claves de encriptación del plano de control (consulta el paso 2). Estas claves de Cloud KMS encriptan los datos que se almacenan y replican en las ubicaciones del entorno de ejecución y del plano de control. Apigee usa estas entidades para encriptar datos de aplicaciones, como KVM, caché y secretos del clientes, que luego se almacenan en la base de datos. Para obtener más información, consulta Acerca de las claves de encriptación de Apigee.

Crea un llavero de claves y una clave de encriptación de la base de datos del entorno de ejecución.
1. Define una variable de entorno para la ubicación de la clave y el llavero de encriptación de la base de datos del entorno de ejecución. Esto garantiza la coherencia cuando se crean y facilita el seguimiento en la documentación.
  
  El valor es la ubicación física en la que se almacenan el llavero de claves y la clave de encriptación de la base de datos del entorno de ejecución.
  Unirregional
  
  Opciones de configuración de región única (en las que solo tienes una instancia en una región): elige entre las ubicaciones regionales de KMS compatibles.
  
  Por ejemplo:
```
RUNTIMEDBKEY_LOCATION="us-west1"
```
  El valor puede ser el mismo que la $RUNTIME_LOCATION (también una región), pero no es necesario que lo sea. Sin embargo, puede haber un beneficio de rendimiento si son iguales.
  Multirregión
  
  Opciones de configuración multirregional: Elige entre ubicaciones multirregionales compatibles (como us o europe) o ubicaciones birregionales.
  
  Por ejemplo:
```
RUNTIMEDBKEY_LOCATION="us"
```
  Te recomendamos que, si tienes una configuración multirregional en EE.UU., uses us para tu ubicación si es posible. De lo contrario, usa nam4.
2. Define variables de entorno para el nombre de las claves y los llaveros de claves de la base de datos.
  El nombre del llavero de claves debe ser único para tu organización. Si creas una segunda región o una posterior, el nombre no puede ser el mismo que los nombres de otros llaveros de claves.
```
RUNTIMEDB_KEY_RING_NAME=YOUR_DB_KEY_RING_NAME
RUNTIMEDB_KEY_NAME=YOUR_DB_KEY_NAME
```
3. (Opcional) Para verificar su trabajo, repita los valores que acaba de configurar. Recuerda que cuando quieras usar una variable en tus comandos, deberás colocar un signo de dólar antes de su nombre ($).
```
echo $RUNTIMEDBKEY_LOCATION
echo $RUNTIMEDB_KEY_RING_NAME
echo $RUNTIMEDB_KEY_NAME
```
4. Crea un llavero de claves nuevo:
```
gcloud kms keyrings create $RUNTIMEDB_KEY_RING_NAME \
  --location $RUNTIMEDBKEY_LOCATION --project $PROJECT_ID
```
  La ubicación de la clave de encriptación de la base de datos del entorno de ejecución de Apigee admite todas las ubicaciones de Cloud KMS compatibles con Cloud HSM y Cloud EKM.
5. Crea una clave:
```
gcloud kms keys create $RUNTIMEDB_KEY_NAME \
  --keyring $RUNTIMEDB_KEY_RING_NAME \
  --location $RUNTIMEDBKEY_LOCATION \
  --purpose "encryption" \
  --project $PROJECT_ID
```
  Con este comando, se crea la clave y se agrega al llavero de claves.
  
  Obtén el ID de 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 clave en una variable de entorno. Usarás esta variable en un comando posterior:
```
RUNTIMEDB_KEY_ID=YOUR_RUNTIMEDB_KEY_ID
```
7. Otorga acceso al agente de servicio de Apigee para que use la clave nueva:
```
gcloud kms keys add-iam-policy-binding $RUNTIMEDB_KEY_NAME \
  --location $RUNTIMEDBKEY_LOCATION \
  --keyring $RUNTIMEDB_KEY_RING_NAME \
  --member serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com \
  --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
  --project $PROJECT_ID
```
  Este comando vincula la clave con el agente de servicio de Apigee.
  
  Cuando se completa correctamente esta solicitud, gcloud muestra una respuesta similar a la siguiente:
```
Updated IAM policy for key [runtime].
bindings:
- members:
  - serviceAccount:service-1234567890@gcp-sa-apigee.iam.gserviceaccount.com
  role: roles/cloudkms.cryptoKeyEncrypterDecrypter
etag: BwWqgEuCuwk=
version: 1
```
  Si recibes un error como el que se muestra a continuación, haz lo 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 electrónico de la cuenta de servicio.
Si usas la residencia de datos, crea un llavero de claves y una clave de encriptación del plano de control. Si no usas la residencia de datos, ve al paso 3.
Nota: Este paso solo es necesario si seleccionaste us (multiple regions in us) o eu (multiple regions in European Union) como la ubicación de hosting del plano de control. Si seleccionaste otra región, ve al paso 3.

Realiza los siguientes pasos para crear un llavero de claves y una clave de encriptación del plano de control.

Define una variable de entorno para la ubicación del llavero y de la clave de encriptación de la base de datos del plano de control:
```
CONTROL_PLANE_LOCATION=YOUR_CONTROL_PLANE_LOCATION
CONSUMER_DATA_REGION=YOUR_CONSUMER_DATA_REGION
```
Aquí:
- CONTROL_PLANE_LOCATION es la ubicación física en la que se almacenarán los datos del plano de control de Apigee. Para obtener una lista de las ubicaciones disponibles del plano de control, 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 obtener una lista de las regiones de datos del consumidor disponibles, consulta Ubicaciones de Apigee.
Define variables de entorno para los llaveros de claves y los nombres de claves de la base de datos del plano de control.

El nombre del llavero de claves debe ser único para 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
```
Aquí:
- CONTROL_PLANE_KEY_RING_NAME es el nombre del llavero de claves que usarás para identificar el llavero de claves de la encriptación de tu plano de control.
- CONTROL_PLANE_KEY_NAME es el nombre de la clave que usarás para identificar la clave de encriptación del plano de control.
- CONSUMER_DATA_KEY_RING_NAME es el nombre del llavero de claves que usarás para identificar el llavero de claves de la encriptación de la región de datos del consumidor.
- CONSUMER_DATA_KEY_NAME es el nombre de la clave que usarás para identificar la clave de encriptación de la región de datos del consumidor.

Crea un llavero de claves nuevo:

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

Crea una clave:

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

Con este comando, se crea la clave y se agrega al llavero de claves.

Obtén el ID de 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

Coloca el ID de 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
```

Otorga acceso al agente de servicio de Apigee para que use la clave nueva:

gcloud kms keys add-iam-policy-binding $CONTROL_PLANE_KEY_NAME \
  --location $CONTROL_PLANE_LOCATION \
  --keyring $CONTROL_PLANE_KEY_RING_NAME \
  --member "serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com" \
  --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-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com" \
 --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
 --project $PROJECT_ID

Este comando vincula la clave con el agente de servicio de Apigee. Cuando se completa correctamente esta solicitud, gcloud muestra una respuesta similar a la siguiente:

Updated IAM policy for key [runtime].
bindings:
- members:
  - serviceAccount:service-1234567890@gcp-sa-apigee.iam.gserviceaccount.com
  role: roles/cloudkms.cryptoKeyEncrypterDecrypter
etag: BwWqgEuCuwk=
version: 1

Si recibes un error como el que se muestra a continuación, haz lo 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 electrónico de la cuenta de servicio.

Consulta también: Solución de problemas de CMEK.

Para crear la organización, envía la siguiente solicitud a la API de la organización 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"'"
  }'
```
Aquí:
- -d define la carga útil de datos para la solicitud. Esta carga útil debe incluir lo siguiente:
  - name: Identifica tu organización nueva. Debe ser el mismo que el ID del proyecto.
  - analyticsRegion: Especifica la ubicación física en la que se almacenarán tus datos de estadísticas.
  - runtimeType: Configura este valor en CLOUD.
  - billingType: Especifica el tipo de facturación de la organización creada.
  - authorizedNetwork: Identifica la red de intercambio de tráfico que especificaste en Configura las herramientas de redes de servicios.
    Nota: Apigee también admite el uso de VPC compartida (es decir, el proyecto de red host no es el mismo que realiza intercambio de tráfico con Apigee). Para usar una red de VPC compartida, usa 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 VPC y el Recurso de REST: organizaciones.
  - runtimeDatabaseEncryptionKeyName: El ID de la clave de encriptación de la aplicación que creaste en el paso anterior. Recuerda que el ID está estructurado como una ruta de archivo. Por ejemplo:
    projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key
Residencia de los 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"'"
  }'
```
Aquí:

-d define la carga útil de datos para la solicitud. Esta carga útil debe incluir lo siguiente:
- name: Identifica tu organización nueva. Debe ser el mismo que el ID del proyecto.
- runtimeType: Configura este valor en 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 conocer los valores admitidos.
- apiConsumerDataEncryptionKeyName: es el ID de la clave de la región de datos del consumidor.
- authorizedNetwork: Identifica la red de intercambio de tráfico que especificaste en Configura las herramientas de redes de servicios.
  Nota: Apigee también admite el uso de VPC compartida (es decir, el proyecto de red host no es el mismo que realiza intercambio de tráfico con Apigee). Para usar una red de VPC compartida, usa 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 VPC y el Recurso de REST: organizaciones.
- runtimeDatabaseEncryptionKeyName: El ID de la clave de encriptación de la aplicación que creaste en el paso anterior. Recuerda que el ID está estructurado como 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 recibes un error, verifica el uso de comillas alrededor de los valores de las variables en la carga útil de datos. Asegúrate de tener comillas dobles alrededor de la variable $PROJECT_ID, como se muestra en el siguiente ejemplo:
```
"'"$PROJECT_ID"'"
```
Si usas strings simples (no variables de entorno) para los valores de solicitud, puedes colocarlas entre comillas dobles dentro de la string de carga útil entre comillas simples, como se muestra en el siguiente ejemplo:
```
'{ "name":"my-gcp-project", ... }'
```
Espera unos minutos.

Para verificar el estado de la solicitud de creación, envía una solicitud GET a la API de la lista de organizaciones 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 los 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 completó:

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

Si Apigee creó una organización nueva de forma correcta, recibirás una respuesta similar a la que se muestra a continuación:

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 los 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 muestra una respuesta de error HTTP, consulta Crea una organización de Apigee.

Sugerencia: Para enumerar las organizaciones de Apigee y los proyectos de Google Cloud asociados a los que tienes permiso de acceso, envía una solicitud GET al siguiente extremo con la API de organizaciones:

Sin residencia de datos:

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

Residencia de los datos:

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

Apigee muestra 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: Crear una instancia del entorno de ejecución

Permisos necesarios para esta tarea

Puedes otorgar al aprovisionador de Apigee un rol predefinido que incluya los permisos necesarios para completar esta tarea, o bien otorgar permisos más detallados para proporcionar el privilegio mínimo necesario. Consulta los roles predefinidos y los permisos de las instancias del entorno de ejecución.

Una instancia del entorno de ejecución es el lugar en el que se almacenan tu proyecto de Apigee y los servicios relacionados. Le proporciona a tus servicios el extremo para el usuario. Para crear una instancia nueva del entorno de ejecución, sigue estos pasos:

Verifica que Apigee haya terminado de crear tu organización. Enviaste una solicitud para crear una organización nueva en Crea una organización de Apigee, pero debes asegurarte de que esté completado antes de continuar.

Para hacerlo, envía la siguiente solicitud a la API de las organizaciones:
Sin residencia de datos
```
curl -i -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID"
```
Residencia de los 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 responderá con sus detalles. Si Apigee responde con un error, espera unos minutos y vuelve a enviar la solicitud.
Como en la tarea anterior en la que creaste una clave de encriptación para la base de datos, ahora debes crear una clave de Cloud KMS que se usará a fin de encriptar datos en el servidor. Para comenzar, 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
```

Aquí:

INSTANCE_NAME: el nombre de la instancia nueva. Por ejemplo: my-runtime-instance. El nombre debe comenzar con una letra en minúscula, puede tener hasta 32 caracteres y solo puede incluir letras en minúscula, números y guiones. No puede comenzar ni terminar con un guion y debe tener al menos dos caracteres.
Sugerencia: El nombre de tu 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 Regiones y zonas disponibles. En este ejemplo, se usa us-west1.
DISK_KEY_RING_NAME es el nombre del llavero de claves de encriptación del disco.
DISK_KEY_NAME es el nombre de la clave de encriptación del disco.

Crea una clave de encriptación del disco:
1. Crea un llavero de claves de disco nuevo:
```
gcloud kms keyrings create $DISK_KEY_RING_NAME \
  --location $RUNTIME_LOCATION \
  --project $PROJECT_ID
```
  El llavero de claves del disco debe estar configurado en la misma ubicación que la instancia. Cada instancia y llavero de claves deben tener su propia ubicación.
2. Crea una clave de disco nueva:
```
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 por la ruta de acceso de la clave. Puedes obtener la ruta de acceso 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 acceso de la clave es similar a la siguiente:
```
projects/PROJECT_ID/locations/RUNTIME_LOCATION/keyRings/my-disk-key-ring/cryptoKeys/my-disk-key
```
3. Coloca la ruta de acceso 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. Otorga acceso al agente de servicio de Apigee para que use la clave nueva:
```
gcloud kms keys add-iam-policy-binding $DISK_KEY_NAME \
  --location $RUNTIME_LOCATION \
  --keyring $DISK_KEY_RING_NAME \
  --member serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com \
  --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
  --project $PROJECT_ID
```
  Este comando vincula la clave con el agente de servicio de Apigee.
Para obtener más información, consulta Acerca de las claves de encriptación de Apigee.
Reserva un rango de IP para que se use en la creación de la instancia de Apigee.
Crea una instancia de entorno de ejecución nueva para tu proyecto mediante el envío de una solicitud POST a la API de instancias 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 los 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"'"]
  }'
```
Aquí:
- consumerAcceptList(Opcional) Especifica una lista de IDs de proyectos de Google Cloud que se pueden conectar de forma privada al adjunto de servicio de la VPC de Apigee. El adjunto 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 más proyectos de la nube que te pertenezcan). De forma predeterminada, usamos el proyecto de la nube que ya está asociado a tu organización de Apigee. Por ejemplo: "consumerAcceptList": ["project1", "project2", "project3"]
  Ten en cuenta que también puedes configurar y cambiar la lista de proyectos aceptados en la IU de la instancia. Para obtener más información, consulta Administra instancias.
Nota: De forma predeterminada, Apigee asigna a la instancia un rango de CIDR disponible con un tamaño de prefijo de /22. En casos de uso avanzados, es posible que debas especificar con exactitud qué rango de IP deseas que use Apigee. Para estos casos, especifica un rango de IP personalizado. El prefijo del rango de IP personalizado puede ser /22 o /28. El rango debe estar disponible como parte de una conexión privada entre tu proyecto y Apigee.
Para especificar tus propios rangos de IP, usa el parámetro de solicitud ipRange como se describe en el documento de referencia de la API de las instancias.

Por ejemplo, crea una variable de entorno que contenga el rango de IP en formato CIDR:
```
MY_IP_RANGE=CIDR_RANGE
```
Por ejemplo:
```
MY_IP_RANGE=10.0.0.1/22
```
En este ejemplo, se muestra cómo puedes especificar rangos de /22 y /28:
```
MY_22_RANGE=10.0.0.1/22,MY_28_RANGE=10.0.0.2/28
```
- 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_22_RANGE,$MY_28_RANGE"'",
    "consumerAcceptList":[ARRAY_OF_PROJECT_IDS]
  }'
```
- Residencia de los 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 rango de IP más adelante. Si alguna vez necesitas cambiar el rango, deberás crear una instancia nueva.
Nota: Además del rango de /22 que se crea, Apigee requiere un rango CIDR de /28 no superpuesto y disponible. Creaste este rango /28 en el paso anterior Configura las herramientas de redes de servicio. Apigee usa el rango /28 para acceder a la instancia a fin de solucionar problemas, y no puede personalizarse ni cambiarse. Consulta también Crea instancias.

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

Si Apigee muestra un error, consulta Crea una instancia nueva.

Para verificar el estado de tu solicitud de creación de instancias del entorno 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 los 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: Crear un entorno

Permisos necesarios para esta tarea

Para crear un entorno y adjuntarlo al entorno de ejecución en la línea de comandos, haz lo siguiente:

Define las variables de entorno que se usarán en esta sección. Las variables de entorno específicas que crees dependerán de si creas un entorno para una suscripción o para pago por uso.
Suscripción

Para un entorno de suscripción, crea estas variables:
```
ENVIRONMENT_NAME="YOUR_ENV_NAME"
ENV_GROUP_NAME="YOUR_ENV_GROUP_NAME"
ENV_GROUP_HOSTNAME="YOUR_ENV_GROUP_HOSTNAME"
```
Aquí:
- ENVIRONMENT_NAME es un nombre de string. Por ejemplo: test.
- ENV_GROUP_NAME es un nombre de string. Por ejemplo: test-group.
- ENV_GROUP_HOSTNAME es un nombre de host del dominio válido. Por ejemplo: foo.example.com.
Pago por uso

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"
```
Aquí:
- ENVIRONMENT_NAME es un nombre de string. Por ejemplo: test.
- ENVIRONMENT_TYPE es el tipo de entorno para este entorno y solo se aplica a los usuarios de pago por uso, que deben especificar uno de estos valores: BASE, INTERMEDIATE o COMPREHENSIVE. Otros usuarios deben omitir el tipo de entorno.
- ENV_GROUP_NAME es un nombre de string. Por ejemplo: test-group.
- ENV_GROUP_HOSTNAME es un nombre de host del dominio válido. Por ejemplo: foo.example.com.

Crea un entorno nuevo con la API de entornos. Los comandos específicos que uses dependerán de si creas un entorno para una suscripción o bien una organización de pago por uso.

Suscripción

Para un entorno de suscripción nuevo, 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"'"
  }'

Residencia de los 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"'"
  }'

Apigee crea un entorno nuevo.

Pago por uso

En un entorno de pago por uso nuevo, 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 los 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 entorno nuevo.

Antes de continuar, verifica que Apigee haya terminado de crear el entorno nuevo mediante una llamada a la API de Environments:

Sin residencia de datos

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

Residencia de los 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"
]

Sugerencia: Para verificar el estado de un entorno específico, envía 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 los 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 los detalles de ese único entorno, por ejemplo:

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

Adjunta el entorno nuevo 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 los 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 verificar si el adjunto está completo, 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 los 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 este, puedes ir al paso siguiente:

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

Crea un grupo de entornos nuevo con el siguiente comando Para obtener más información, consulta Información acerca de los entornos y 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 los 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"'"]
  }'

Espera a que se complete la operación. Puedes verificar el estado de tu grupo nuevo mediante 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 los datos

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

Conecta el entorno nuevo al grupo de entornos nuevo 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 los 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"'"
  }'

Para verificar 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 los datos

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

Paso 8: Configurar el enrutamiento

En este paso, debes configurar cómo las aplicaciones cliente se comunican con Apigee. El tráfico de cliente a Apigee también se llama tráfico “ascendente”. Las opciones de configuración ascendentes incluyen las siguientes: Ve a la opción de configuración que deseas usar y realiza los pasos para esa opción:

Tipo de acceso	Descripción de los procesos de configuración e implementación
Interno con intercambio de tráfico de VPC	Permite solo el acceso interno a tus proxies de API. Debes crear una VM nueva dentro de la red y conectarte a ella. Desde la VM nueva, 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 administrado (MIG) para enviar el tráfico de la API del servicio de backend de un balanceador de cargas global a Apigee. Con esta configuración, Apigee solo puede conectarse a la VPC de intercambio de tráfico. Esta configuración te permite enviar solicitudes de proxy de API de Apigee desde cualquier máquina habilitada para la red.
Interno con PSC (nuevo)	Permite solo el acceso interno a tus proxies de API desde cualquiera de tus proyectos de Google Cloud con Private Service Connect (PSC). PSC permite establecer una conexión privada entre un productor de servicios (Apigee) y un consumidor de servicios (el proyecto de VPC con intercambio de tráfico o uno o más proyectos de Cloud que tú controlas). Con este método, las solicitudes pasan a través de un extremo de servicio o un balanceador de cargas interno regional a un único punto de adjunto, llamado adjunto de servicio. Esta configuración permite que tus clientes internos envíen solicitudes de proxy de API de Apigee desde cualquier máquina habilitada para la red.
Externo con PSC (nuevo)	Permite el acceso externo a tus proxies de API con Private Service Connect (PSC). Utiliza 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 con intercambio de tráfico o uno o más proyectos de Cloud que tú controlas). Con este método, las solicitudes pasan a través de un balanceador de cargas externo global o un balanceador de cargas externo regional a un único punto de adjunto, llamado adjunto de servicio. Esta configuración te permite enviar solicitudes de proxy de API de Apigee desde cualquier máquina habilitada para la red.

Cada uno de estos enfoques de enrutamiento se presenta en las instrucciones que aparecen a continuación.

Enrutamiento interno (VPC)

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

Opciones de TLS: Tienes dos opciones si quieres realizar llamadas al proxy de API desde clientes internos con TLS habilitada:
- (Opción 1) Configura la opción de un balanceador de cargas interno (ILB):
  1. Crea un grupo de instancias administrado (MIG) en tu proyecto. Para crear el MIG, sigue los pasos 8 a, 8b y 8c en Enrutamiento externo (MIG).
  2. Crea y configura un balanceador de cargas de HTTPS(S) interno (ILB) y conecta el MIG que creaste al servicio de backend del ILB, como se explica en Configura el balanceo de cargas de HTTP(S) interno con los backends de grupos de instancias de VM. Con la configuración del ILB, tienes control total sobre los certificados de la AC que se usan con el ILB.
  3. Ve a Llama a un proxy de API con acceso solo interno para probar la configuración.
- (Opción 2) Usa el nombre de dominio completamente calificado predeterminado y la IP del balanceador de cargas interno de la instancia de Apigee. Este caso se recomienda solo para realizar pruebas y no para un entorno de producción. En este caso, se usan los certificados autofirmados creados por Apigee con el balanceador de cargas interno de Apigee y no los puedes cambiar. Consulta Llama a un proxy de API con acceso solo interno.
Opción sin TLS: Si no necesitas habilitar la finalización de TLS, puedes llamar a los proxies de API en los que el cliente inhabilita TLS. Por ejemplo, si usas la opción -k con cURL, puedes inhabilitar TLS. Consulta Llama a un proxy de API con acceso solo 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 administrado (MIG) a fin de enviar tráfico de API desde el servicio de backend de un balanceador de cargas global a Apigee. Debes hacer esto para poder enviar una solicitud desde un cliente externo hacia la instancia del entorno de ejecución de Apigee.

Permisos necesarios para esta tarea

Puedes otorgar al aprovisionador de Apigee un rol predefinido que incluya los permisos necesarios para completar esta tarea, o bien otorgar permisos más detallados a fin de proporcionar el privilegio mínimo necesario. Consulta Roles predefinidos y Permisos de enrutamiento de acceso.

El proceso general es el siguiente:

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

Cada uno de estos pasos se describe en las siguientes secciones.

Paso 8a: Habilita el acceso privado a Google para una subred de tu red de VPC

Si quieres habilitar el Acceso privado a Google para una subred de tu red de VPC, sigue los pasos que se indican en Habilita el Acceso privado a Google.

Paso 8b: Configura variables de entorno

En las instrucciones de esta sección, se usan variables de entorno para hacer referencia a strings que se usan de forma repetida. Te recomendamos que configures lo siguiente 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

Deberá usar estas variables muchas veces durante los procesos restantes. Si deseas configurar varias regiones, crea variables con valores específicos para cada región.

Sugerencia: Para obtener la dirección IP correcta de la instancia de Apigee, usa la API de instancias, 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 los datos:

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

Apigee responde con los detalles de 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 muestra los detalles de la instancia para cada ubicación regional. En ese caso, debes crear un grupo de instancias administrado (MIG) diferente para cada ubicación cuando sigues los pasos de la siguiente sección.

Paso 8c: Crea un grupo de instancias administrado

En este paso, crearás y configurarás un grupo de instancias administrado (MIG). En un paso posterior, agregarás el MIG a un servicio de backend que está conectado a un balanceador de cargas global. Se requiere un MIG para enviar tráfico de API desde el servicio de backend del balanceador de cargas global a Apigee.

Para crear un MIG, sigue estos pasos:

Crea una plantilla de instancias mediante la ejecución del 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-10 \
--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 se puede ver en este comando, las máquinas son del tipo e2-medium. Ejecutan Debian 10 y tienen 20 GB de disco. La secuencia de comandos startup-script.sh configura el MIG para enrutar el tráfico entrante desde el balanceador de cargas hasta la instancia de Apigee.

Para crear un grupo de instancias administrado, ejecuta 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

Configura el ajuste de escala automático para el grupo mediante la ejecución del siguiente comando:
Nota: Un MIG regional con instancias e2-medium puede admitir un máximo de 6 Gbps. Si eso no es suficiente para tus necesidades de capacidad de procesamiento, considera aumentar el tamaño de la VM o la cantidad 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
```

Define un puerto con nombre mediante la ejecución del 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 SSL y una clave para el balanceador de cargas

Solo debes crear las credenciales una vez, ya sea que instales en una o varias regiones. En un paso posterior, asociarás estas credenciales con el proxy HTTPS de destino del balanceador de cargas.

Puedes crear las credenciales de la siguiente manera:

Tu propio certificado de una autoridad certificada
Un certificado SSL administrado por Google
Un certificado autofirmado (no se recomienda para la producción)

Si deseas obtener más información sobre la creación y el uso de certificados SSL para el balanceador de cargas de Google Cloud, consulta Certificados SSL y Descripción general del certificado SSL.

En el siguiente ejemplo, se crea un certificado SSL administrado por Google:

Crea estas variables de entorno:
```
CERTIFICATE_NAME=YOUR_CERT_NAME
DOMAIN_HOSTNAME=YOUR_DOMAIN_HOSTNAME 
```
Establece DOMAIN_HOSTNAME en un nombre de host de dominio válido que hayas registrado. En un paso posterior, obtendrás la dirección IP del balanceador de cargas y actualizarás el registro A del dominio para que apunte a esa dirección. Por ejemplo, el nombre de host del dominio podría tener el siguiente aspecto: foo.example.com.
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 verificar el estado del aprovisionamiento, ejecuta este comando:
```
gcloud compute ssl-certificates describe $CERTIFICATE_NAME \
 --global \
 --format="get(name,managed.status, managed.Status)"
```
Nota: Puedes crear varios registros A de DNS para tus nombres de host del grupo de entornos que apuntan a la misma dirección IP del balanceador de cargas.

Paso 8e: Crea un balanceador de cargas global

Cree una verificación de estado.
```
gcloud compute health-checks create https HEALTH_CHECK_NAME \
--project $PROJECT_ID --port 443 --global \
--request-path /healthz/ingress
```
Usarás esta verificación de estado para garantizar que el servicio de backend se esté ejecutando. Para configurar verificaciones de estado más avanzadas en un proxy específico, consulta Realiza verificaciones de estado.
Nota: Si recibes el siguiente error mientras intentas crear una verificación de estado, haz lo siguiente:
```
ERROR: unrecognized arguments: --global,
```
Intenta actualizar gcloud mediante el comando gcloud components update.
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: Como se documenta en la referencia de las propiedades de extremos de Apigee, la entrada de Apigee (balanceador de cargas interno) tiene un tiempo de espera predeterminado de 300 segundos. Establecer el tiempo de espera de servicios de backend del balanceador de cargas en 302 segundos permitirá que el comando de servicios de backend se complete por completo dentro de Apigee en caso de que haya transacciones de larga duración. Establecer este valor en un valor menor, como 60 segundos, puede hacer que el balanceador de cargas agote el tiempo de espera antes de que se complete la solicitud, lo que genera 502 respuestas.
Agrega el MIG a tu servicio de backend con el siguiente comando:
Multirregión: A fin de obtener una configuración multirregional, debes crear un MIG independiente para cada uno, luego repite este paso para agregar cada MIG al servicio de backend. Asegúrate de sustituir las variables REGION y MIG_NAME apropiadas para 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
```

Crea un mapa de URL de balanceo de cargas con el siguiente comando:

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

Crea un proxy HTTPS de destino de balanceo de cargas 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: Obtén una dirección IP reservada y crea reglas de firewall

Debes asignar una dirección IP al balanceador de cargas y, luego, crear reglas que permitan al balanceador de cargas acceder al MIG. Solo debes realizar este paso una vez, ya sea que instales en una o varias regiones.

Reserva una dirección IP para el balanceador de cargas:

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

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

Obtén una dirección IP reservada mediante la ejecución del siguiente comando:

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

Paso importante: Ve al sitio, host de DNS o ISP donde se administran tus registros DNS y asegúrate de que el registro DNS de tu dominio se resuelva en la dirección IP del balanceador de cargas de Google Cloud. Esta dirección es el valor de IP que se muestra en el último paso. Si deseas obtener más detalles, consulta Actualiza los registros A y AAAA de DNS para que apunten a la dirección IP del balanceador de cargas.
Crea una regla de firewall que permita al balanceador de cargas acceder al MIG con 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 rangos de direcciones IP 130.211.0.0/22 y 35.191.0.0/16 son los rangos de direcciones IP de origen para el balanceo de cargas de Google. Esta regla de firewall permite a Google Cloud Load Balancing realizar solicitudes de verificación de estado al MIG.

El aprovisionamiento de Apigee se completó. Ve a Implementa un proxy de muestra.

Enrutamiento interno (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 con Private Service Connect (PSC).

Tienes dos opciones para configurar el acceso interno con PSC:

Extremo de servicio: las solicitudes pasan a través de un extremo de servicio a un único punto de adjunto, llamado adjunto de servicio.
Balanceador de cargas regional interno: las solicitudes pasan a través de un balanceador de cargas de HTTP(S) regional interno. Consulta también Balanceo de cargas global frente a regional.

Selecciona la pestaña que aparece a continuación para la opción de configuración y sigue los pasos que se indican a continuación:

Extremo de servicio

Permisos necesarios para esta tarea

Crea un extremo de servicio de PSC para el adjunto de servicio

Obtén el adjunto de servicio de la instancia que creaste antes:

Sin residencia de datos

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

Residencia de los datos

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

En el siguiente resultado de muestra, el valor serviceAttachment se muestra con letra 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 usaste para crear tu organización de Apigee siempre aparece en la lista consumerAcceptList. En el resultado de ejemplo anterior, es el único proyecto en la lista.

Crea un extremo de servicio de PSC que apunte al adjunto de servicio que obtuviste del cuerpo de la respuesta de la instancia en el paso anterior, como se explica en Crea un extremo de Private Service Connect.
Para probar la configuración, ve a Llama a un proxy de API con acceso solo interno.

Balanceo de cargas regional interno

Permisos necesarios para esta tarea

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

El balanceador de cargas 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 verificaciones de estado activas. En su lugar, usa la detección de valores atípicos.
La cantidad de proyectos de Google Cloud que se pueden conectar a una instancia de Apigee a través de PSC se limita a 50, y cada proyecto puede crear hasta 20 conexiones. Consulta Configura el enrutamiento. Consulta también Límites.
Nota: Puedes controlar la lista de proyectos de Google Cloud conectados a una instancia a través del campo consumerAcceptList de la API de instancias.
Si se quita un proyecto de Google Cloud de consumerAcceptList, los NEGs de PSC existentes en ese proyecto seguirán funcionando. Sin embargo, se rechazarán todos los NEGs nuevos. Debes borrar los NEGs existentes si quitas sus proyectos asociados de consumerAcceptList. Como alternativa, puedes volver a crear la instancia de Apigee, que vuelve a crear el adjunto del servicio en el proyecto de Apigee.

Paso 8a: Configura variables de entorno

En las instrucciones de esta sección, se usan variables de entorno para hacer referencia a strings que se usan de forma repetida. Asegúrate de haber establecido las variables en Define las variables de entorno.

Además, configura las siguientes variables de entorno:

NEG_NAME=YOUR_NEG_NAME"
TARGET_SERVICE=YOUR_TARGET_SERVICE"
NETWORK_NAME=YOUR_NETWORK_NAME"
SUBNET_NAME=YOUR_SUBNET_NAME"

Aquí:

NEG_NAME: un nombre para el grupo de extremos de red.
TARGET_SERVICE: el adjunto de servicio al que deseas conectarte. Por ejemplo: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7.
NETWORK_NAME: nombre de la red en la que se crea el NEG (opcional). Si omites este parámetro, se usa la red del proyecto default.
SUBNET_NAME: nombre de la subred que se usa para la conectividad privada al productor. El tamaño de subred puede ser pequeño: el NEG de PSC solo necesita una IP de la subred. Para Apigee, solo se necesita un NEG de PSC por región. Las VMs u otras entidades pueden compartir y usar la subred. Si no se especifica una subred, los extremos de red pueden pertenecer a cualquier subred en la región donde se crea el grupo de extremos de red.
NOTA: Si especificas el parámetro --network, también debes especificar --subnet.

Paso 8b: Crear una subred de solo proxy

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 8c: Crea un grupo de extremos de red (NEG)

Obtén el adjunto de servicio de la instancia que creaste antes:

Sin residencia de datos

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

Residencia de los datos

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

En el siguiente resultado de muestra, el valor serviceAttachment se muestra con letra 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 usaste para crear tu organización de Apigee siempre aparece en la lista consumerAcceptList. En el resultado de ejemplo anterior, es el único proyecto en la lista.

Crea un NEG de Private Service Connect que apunte al adjunto de servicio que obtuviste del cuerpo de 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 \
--project=$PROJECT_ID
```
Donde $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 crea la instancia del entorno de ejecución de Apigee.

Paso 8d: Configurar el balanceador de cargas interno regional

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

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

Reemplaza ADDRESS_NAME con un nombre para el 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

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_REGION \
--project=$PROJECT_ID

Reemplaza BACKEND_SERVICE_NAME por el nombre del servicio de backend.

Agrega el servicio de backend al NEG.
```
gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
--network-endpoint-group=$NEG_NAME \
--region=$RUNTIME_LOCATION \
--project=$PROJECT_ID
```
Reemplaza lo siguiente:
- NEG_NAME: es el nombre del grupo de extremos de red.
- BACKEND_SERVICE_NAME por el nombre del servicio de backend.
Si quieres crear un balanceador de cargas de HTTPS, debes tener un recurso de certificado SSL para usar en el proxy HTTPS.

Usa este comando para crear un recurso de certificado SSL autoadministrado. Para crear un certificado SSL autoadministrado, necesitas un archivo de clave privada local y un archivo de certificado local. Si necesitas crear estos archivos, consulta el Paso 1 sobre el uso de certificados SSL autoadministrados.

Nota: El balanceador de cargas regional interno no admite los certificados administrados por Google.
```
gcloud compute ssl-certificates create CERTIFICATE \
--certificate LB_CERT \
--private-key LB_PRIVATE_KEY
--region=$RUNTIME_LOCATION --project=$PROJECT_ID
```
Reemplaza lo siguiente:
- CERTIFICATE: un nombre para el certificado
- LB_CERT: la ruta al archivo del certificado con formato PEM para tu certificado autoadministrado.
- LB_PRIVATE_KEY: la ruta al archivo de claves privadas con formato PEM para tu certificado autoadministrado.
Crea un mapa de URL para el balanceador de cargas.

Un mapa de URL debe hacer referencia a un servicio de backend predeterminado. Configura el servicio de backend que acabas de crear como predeterminado.
```
gcloud compute url-maps create URL_MAP_NAME \
--default-service=DEFAULT_BACKEND_SERVICE_NAME \
--global --project=$PROJECT_ID
```
Reemplaza lo siguiente:
- URL_MAP_NAME: un nombre para el mapa de URL
- DEFAULT_BACKEND_SERVICE_NAME: el nombre del servicio de backend predeterminado del balanceador de cargas. El valor predeterminado se usa cuando ninguna regla de host coincide con el nombre de host solicitado.
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
```
Reemplaza lo siguiente:
- PROXY_NAME: un nombre para el proxy HTTPS de destino.
- URL_MAP_NAME: el nombre del mapa de URL.
- CERTIFICATE: el nombre del recurso de certificado.

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

Reemplaza lo siguiente:

FWD_RULE: un nombre para la regla de reenvío.
ADDRESS_NAME: el recurso de dirección IP que reservaste para usar en la regla de reenvío.
PROXY_NAME: el nombre del proxy HTTPS de destino.

El aprovisionamiento de Apigee se completó. Ve a Implementa un proxy de muestra.

Enrutamiento externo (PSC)

En esta sección, se describe cómo configurar el enrutamiento externo a través de Private Service Connect (PSC) para permitir la comunicación entre Apigee y las VPC que controlas. Debes hacer esto para poder enviar una solicitud desde un cliente externo hacia la instancia del entorno de ejecución de Apigee.

Permisos necesarios para esta tarea

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

El balanceador de cargas 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 verificaciones de estado activas. En su lugar, usa la detección de valores atípicos.
La cantidad de proyectos de Google Cloud que se pueden conectar a una instancia de Apigee a través de PSC se limita a 50, y cada proyecto puede crear hasta 20 conexiones. Consulta Configura el enrutamiento. Consulta también Límites.
Nota: Puedes controlar la lista de proyectos de Google Cloud conectados a una instancia a través del campo consumerAcceptList de la API de instancias.
Si se quita un proyecto de Google Cloud de consumerAcceptList, los NEGs de PSC existentes en ese proyecto seguirán funcionando. Sin embargo, se rechazarán todos los NEGs nuevos. Debes borrar los NEGs existentes si quitas sus proyectos asociados de consumerAcceptList. Como alternativa, puedes volver a crear la instancia de Apigee, que vuelve a crear el adjunto del servicio en el proyecto de Apigee.

Paso 8b: Crear un NEG y configura el balanceador de cargas

Puedes crear un balanceador de cargas global o regional.

Balanceo de cargas global externo

Configura un balanceador de cargas HTTP(S) externo global (esquema de balanceo de cargas configurado como EXTERNAL_MANAGED).

Aunque el NEG de Private Service Connect es regional, todos los demás componentes del balanceo de cargas de esta configuración son globales.

Asegúrate de haber configurado las variables de entorno en Define las variables de entorno.

Obtén el adjunto de servicio de la instancia que creaste antes:

Sin residencia de datos

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

Residencia de los datos

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

En el siguiente resultado de muestra, el valor serviceAttachment se muestra con letra 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 usaste para crear tu organización de Apigee siempre aparece en la lista consumerAcceptList. En el resultado de ejemplo anterior, es el único proyecto en la lista.

Crea un NEG de Private Service Connect que apunte al adjunto de servicio que obtuviste del cuerpo de 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
```
Reemplaza lo siguiente:
- NEG_NAME: un nombre para el grupo de extremos de red.
- TARGET_SERVICE: el adjunto de servicio al que deseas conectarte. Usa el valor del adjunto de servicio que muestra el comando anterior. Por ejemplo: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7
- NETWORK_NAME: Nombre de la red en la que se crea el NEG (opcional). Si omites este parámetro, se usa la red del proyecto default.
- SUBNET_NAME: Nombre de la subred que se usa para la conectividad privada al productor. El tamaño de subred puede ser pequeño: el NEG de PSC solo necesita una IP de la subred. Para Apigee, solo se necesita un NEG de PSC por región. Las VMs y otras entidades pueden compartir y usar la subred. Si no se especifica una subred, los extremos de red pueden pertenecer a cualquier subred en la región donde se crea el grupo de extremos de red.
  Nota: Si especificas el parámetro --network, también debes 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 crea la instancia del entorno de ejecución de Apigee. Si aún no lo hiciste, crea una variable de entorno para conservar el ID del proyecto, ya que se usará en la mayoría de los siguientes comandos.

Reserva una dirección IPv4 externa global para el balanceador de cargas.

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

Reemplaza ADDRESS_NAME con un nombre para el 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

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

Reemplaza BACKEND_SERVICE_NAME por el nombre del servicio de backend.

Agrega el servicio de backend al NEG.
```
gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
    --network-endpoint-group=NEG_NAME \
    --network-endpoint-group-region=REGION \
    --global --project=$PROJECT_ID
```
Reemplaza lo siguiente:
- BACKEND_SERVICE_NAME: el nombre del servicio de backend.
- NEG_NAME: es el nombre del grupo de extremos de red.
- REGION: la región del grupo de extremos de red
Crea un mapa de URL para el balanceador de cargas.

Un mapa de URL debe hacer referencia a un servicio de backend predeterminado. Configura el servicio de backend que acabas de crear como predeterminado.
```
gcloud compute url-maps create URL_MAP_NAME \
    --default-service=DEFAULT_BACKEND_SERVICE_NAME \
    --global --project=$PROJECT_ID
```
Reemplaza lo siguiente:
- URL_MAP_NAME: un nombre para el mapa de URL
- DEFAULT_BACKEND_SERVICE_NAME: el nombre del servicio de backend predeterminado del balanceador de cargas. El valor predeterminado se usa cuando ninguna regla de host coincide con el nombre de host solicitado.
Crea el proxy HTTPS de destino.

Si quieres crear un balanceador de cargas de HTTPS, debes tener un recurso de certificado SSL para usar en el proxy HTTPS. Puedes crear un recurso de certificado SSL a través de un certificado SSL administrado por Google o un certificado SSL autoadministrado. Se recomienda usar certificados administrados por Google, ya que Google Cloud obtiene, administra y renueva estos certificados de manera automática.

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

Usa este comando para crear un recurso de certificado SSL administrado por Google:
```
gcloud compute ssl-certificates create CERTIFICATE \
    --domains DOMAIN --project=$PROJECT_ID
```
Reemplaza lo siguiente:
- CERTIFICATE: un nombre para el certificado
- DOMAIN: el nombre de dominio del balanceador de cargas
Usa este comando para crear un recurso de certificado SSL autoadministrado. Para crear un certificado SSL autoadministrado, necesitas un archivo de clave privada local y un archivo de certificado local. Si necesitas crear estos archivos, consulta el Paso 1 sobre el uso de certificados SSL autoadministrados.
```
gcloud compute ssl-certificates create CERTIFICATE \
    --certificate LB_CERT \
    --private-key LB_PRIVATE_KEY --project=$PROJECT_ID
```
Reemplaza lo siguiente:
- CERTIFICATE: un nombre para el certificado
- LB_CERT: la ruta al archivo del certificado con formato PEM para tu certificado autoadministrado.
- LB_PRIVATE_KEY: la ruta al archivo de claves privadas con formato PEM para tu certificado autoadministrado.
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
```
Reemplaza lo siguiente:
- PROXY_NAME: un nombre para el proxy HTTPS de destino.
- URL_MAP_NAME: el nombre del mapa de URL.
- CERTIFICATE: el nombre del recurso de certificado.

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

Reemplaza lo siguiente:

FWD_RULE: un nombre para la regla de reenvío.
ADDRESS_NAME: el recurso de dirección IP que reservaste para usar en la regla de reenvío.
PROXY_NAME: el nombre del proxy HTTPS de destino.

Balanceo de cargas regional externo

Configura un balanceador de cargas HTTP(S) externo regional. Consulta también Descripción general del balanceador de cargas HTTP(S) externo.

Asegúrate de haber establecido las variables en Define las variables de entorno.
Crea una subred de solo proxy:
Nota: Esta es una operación única. Esta subred de solo proxy es necesaria solo una vez por proyecto de Google Cloud para cualquier balanceador de cargas regional basado en Envoy. Consulta también Subredes de solo proxy para balanceadores de cargas 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
```
Reemplaza lo siguiente:
- SUBNET_NAME: el nombre de la subred.
- (Opcional) NETWORK_NAME: Nombre de la red en la que se crea la subred. Si omites este parámetro, se usa la red predeterminada del proyecto.

Obtén el adjunto de servicio de la instancia que creaste antes:

Sin residencia de datos

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

Residencia de los datos

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

En el siguiente resultado de muestra, el valor serviceAttachment se muestra con letra 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 usaste para crear tu organización de Apigee siempre aparece en la lista consumerAcceptList. En el resultado de ejemplo anterior, es el único proyecto en la lista.

Crea un grupo de extremos 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
```
Reemplaza lo siguiente:
- NEG_NAME: es el nombre del grupo de extremos de red.
- TARGET_SERVICE: El nombre del adjunto de servicio al que deseas conectarte. Por ejemplo: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7.

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

Reemplaza BACKEND_SERVICE_NAME por el nombre del servicio de backend.

Agrega el servicio de backend al NEG.
```
gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --network-endpoint-group=NEG_NAME \
  --region=$RUNTIME_LOCATION  \
  --project=$PROJECT_ID
```
Reemplaza lo siguiente:
- BACKEND_SERVICE_NAME: el nombre del servicio de backend.
- NEG_NAME: es el nombre del grupo de extremos de red.
Crea un mapa de URL para el balanceador de cargas.

Un mapa de URL debe hacer referencia a un servicio de backend predeterminado. Configura el servicio de backend que acabas de crear como predeterminado.
```
gcloud compute url-maps create URL_MAP_NAME \
  --default-service=DEFAULT_BACKEND_SERVICE_NAME \
  --region=$RUNTIME_LOCATION  \
  --project=$PROJECT_ID
```
Reemplaza lo siguiente:
- URL_MAP_NAME: un nombre para el mapa de URL
- DEFAULT_BACKEND_SERVICE_NAME: el nombre del servicio de backend predeterminado del balanceador de cargas. El valor predeterminado se usa cuando ninguna regla de host coincide con el nombre de host solicitado.
Crea el proxy HTTPS de destino.

Si deseas crear un balanceador de cargas HTTPS, debes tener un recurso de certificado SSL para usar en el proxy de destino HTTPS.

Usa este comando para crear un recurso de certificado SSL autoadministrado. Para crear un certificado SSL autoadministrado, necesitas un archivo de clave privada local y un archivo de certificado local. Si necesitas crear estos archivos, consulta el Paso 1 sobre el uso de certificados SSL autoadministrados.

Nota: El balanceador de cargas regional interno no admite los certificados administrados por Google.
```
gcloud compute ssl-certificates create CERTIFICATE \
  --certificate LB_CERT \
  --private-key LB_PRIVATE_KEY --region=$RUNTIME_LOCATION \
  --project=$PROJECT_ID
```
Reemplaza lo siguiente:
- CERTIFICATE: un nombre para el certificado
- LB_CERT: la ruta al archivo del certificado con formato PEM para tu certificado autoadministrado.
- LB_PRIVATE_KEY: la ruta al archivo de claves privadas con formato PEM para tu certificado autoadministrado.
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
```
Reemplaza lo siguiente:
- PROXY_NAME: un nombre para el proxy HTTPS de destino.
- URL_MAP_NAME: el nombre del mapa de URL.
- CERTIFICATE: el nombre del recurso de certificado.

Reserva una dirección externa regional para el balanceador de cargas. Ten en cuenta que el nivel de red se debe establecer en STANDARD.

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

Reemplaza ADDRESS_NAME con un nombre para el 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

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

Reemplaza lo siguiente:

FWD_RULE: un nombre para la regla de reenvío.
ADDRESS_NAME: el recurso de dirección IP que reservaste para usar en la regla de reenvío.
PROXY_NAME: el nombre del proxy HTTPS de destino.

El aprovisionamiento de Apigee se completó. Ve a Implementa un proxy de muestra.

Paso 9: Implementar un proxy de muestra

Permisos necesarios para esta tarea

Para implementar y crear proxies se requiere un conjunto mínimo de permisos. Si tienes el rol Apigee Org Admin, puedes completar esta tarea. Para obtener información sobre otros roles que puedes emplear, consulta Roles de Apigee.

Descarga el proxy de muestra desde GitHub. El destino del proxy es el servicio httpbin.org, que es un servicio de solicitud y respuesta público de uso frecuente.

Sube el paquete del proxy de API al entorno de ejecución mediante la API de apis de Apigee:

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 los 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'

En el ejemplo anterior, PATH_TO_ZIP_FILE es la ruta de acceso al directorio que contiene el archivo ZIP descargado.

Implementa el proxy de API en el entorno que creaste antes:

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 los 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"

Confirma que la implementación se haya 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 los 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"

Llama al proxy de API

Envía una solicitud al proxy de API desde cualquier máquina habilitada para la red a través de la ejecución del 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 los datos

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

Si obtienes un error como CONNECT_CR_SRVR_HELLO:sslv3 alert handshake failure, verifica si se aprovisionó el certificado SSL que creaste antes. Usa este comando para verificar 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 se realiza correctamente, el proxy de API de muestra da como resultado 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 la implementación de proxies, además de información adicional de solución de problemas, consulta Implementa un proxy de API.

Aprovisiona una organización pagada con intercambio de tráfico entre VPC

Resumen de los pasos

Paso 1: Definir las variables de entorno

Sin residencia de datos

Residencia de los datos

Sin residencia de datos

Residencia de los datos

Paso 2: Habilitar las API

Permisos necesarios para esta tarea

Paso 3: Crear la identidad de servicio de Apigee

Paso 4: Configurar las herramientas de redes de servicio

Permisos necesarios para esta tarea

Paso 5: Crear una organización

Permisos necesarios para esta tarea

Unirregional

Multirregión

Sin residencia de datos

Residencia de los datos

Sin residencia de datos

Residencia de los datos

Sin residencia de datos

Residencia de los datos

Paso 6: Crear una instancia del entorno de ejecución

Permisos necesarios para esta tarea

Sin residencia de datos

Residencia de los datos

Sin residencia de datos

Residencia de los datos

Sin residencia de datos

Residencia de los datos

Paso 7: Crear un entorno

Permisos necesarios para esta tarea

Suscripción

Pago por uso

Suscripción

Sin residencia de datos

Residencia de los datos

Pago por uso

Sin residencia de datos

Residencia de los datos

Sin residencia de datos

Residencia de los datos

Sin residencia de datos

Residencia de los datos

Sin residencia de datos

Residencia de los datos

Sin residencia de datos

Residencia de los datos

Sin residencia de datos

Residencia de los datos

Sin residencia de datos

Residencia de los datos

Sin residencia de datos

Residencia de los datos

Paso 8: Configurar el enrutamiento

Enrutamiento interno (VPC)

Enrutamiento externo (MIG)

Permisos necesarios para esta tarea

Paso 8a: Habilita el acceso privado a Google para una subred de tu red de VPC

Paso 8b: Configura variables de entorno

Paso 8c: Crea un grupo de instancias administrado

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

Paso 8e: Crea un balanceador de cargas global

Paso 8f: Obtén una dirección IP reservada y crea reglas de firewall

Enrutamiento interno (PSC)

Extremo de servicio

Permisos necesarios para esta tarea

Crea un extremo de servicio de PSC para el adjunto de servicio

Sin residencia de datos

Residencia de los datos

Balanceo de cargas regional interno

Permisos necesarios para esta tarea

Paso 8a: Configura variables de entorno

Paso 8b: Crear una subred de solo proxy

Paso 8c: Crea un grupo de extremos de red (NEG)

Sin residencia de datos

Residencia de los datos

Paso 8d: Configurar el balanceador de cargas interno regional

Enrutamiento externo (PSC)

Permisos necesarios para esta tarea