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
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"
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.
-
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"
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.
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.
-
AUTH define el encabezado
- (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
-
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.
- 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.
- RANGE_NAME es el nombre del rango de direcciones IP que estás creando.
Puedes nombrar el rango como desees. Por ejemplo:
- 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 CIDR192.168.0.0/22
, especifica192.168.0.0
como la dirección y22
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 CIDR192.168.0.0/28
, especifica192.168.0.0
como la dirección y28
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.
- 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
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.
Paso 5: Crear una organización
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.
-
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
oeurope
) 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, usanam4
. - 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
- (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
- 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.
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
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
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.
- 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.
-
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 enCLOUD
.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.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 enCLOUD
.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.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.
Realiza los siguientes pasos para crear un llavero de claves y una clave de encriptación del plano de control.
Consulta también: Solución de problemas de CMEK.
Paso 6: Crear una instancia 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
- 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. - 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:
- 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.
- 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
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
.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.
- Crea un llavero de claves de disco nuevo:
- 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.
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"
Aquí:
Paso 7: Crear un entorno
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
oCOMPREHENSIVE
. 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" ]
- 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):
- 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).
- 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.
- 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 1) Configura la opción de un balanceador de cargas interno (ILB):
- 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.
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 likeVPC_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.
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 comandosstartup-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:
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)"
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.
- 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
- Agrega el MIG a tu servicio de backend con el siguiente comando:
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
y35.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
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" } ] }
- 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
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.
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" } ] }
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
- 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.
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.
Reemplaza BACKEND_SERVICE_NAME por el nombre del servicio de backend.
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.
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" } ] }
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.
- $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
- 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.
Reemplaza BACKEND_SERVICE_NAME por el nombre del servicio de backend.
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:
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" } ] }
- 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
- 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.
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.
Reemplaza BACKEND_SERVICE_NAME por el nombre del servicio de backend.
El aprovisionamiento de Apigee se completó. Ve a Implementa un proxy de muestra.
Paso 9: Implementar un proxy de muestra
- 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 esACTIVE
.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.