Se usó la API de Cloud Translation para traducir esta página.

Comienza a usar el procesador de extensiones de Apigee

Esta página se aplica a Apigee y Apigee Hybrid.

Consulta la documentación de Apigee Edge.

En esta página, se describe cómo configurar el procesador de extensiones de Apigee para habilitar la aplicación de políticas de API para el tráfico de API con un balanceador de cargas habilitado para extensiones de servicio.

Para obtener más información sobre los casos de uso sugeridos y los beneficios de usar Apigee Extension Processor para la administración de APIs, consulta la Descripción general de Apigee Extension Processor.

El procesador de extensiones de Apigee es una extensión de tráfico (un tipo de extensión de servicio) que te permite usar Cloud Load Balancing para enviar llamadas externas desde la ruta de procesamiento de datos del balanceador de cargas de aplicaciones al procesador de extensiones de Apigee. Una vez que se configuran el balanceador de cargas y la extensión de tráfico, el balanceador de cargas procesa el tráfico de la API. Las políticas del procesador de extensiones de Apigee se aplican al tráfico de la API a través de las llamadas externas de extensión de tráfico.

En las siguientes secciones, se te guiará a través de los pasos necesarios para configurar los elementos clave del procesador de extensiones de Apigee:

Configura un balanceador de cargas para un servicio de backend.

Configura el procesador de extensiones de Apigee.

Configura la extensión de tráfico.

Usa políticas con el Extension Processor.

Antes de comenzar

Antes de comenzar a configurar el procesador de extensiones de Apigee, asegúrate de completar las siguientes tareas:

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Apigee, Compute Engine, and Network Services APIs.

Enable the APIs

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Apigee, Compute Engine, and Network Services APIs.

Enable the APIs

Instala Google Cloud CLI.

Después de instalar Google Cloud CLI, ejecuta el comando gcloud components update para obtener los componentes de gcloud más recientes.
Aprovisiona una instancia de Apigee con la versión 1-15-0-apigee-2 o una posterior, si aún no lo hiciste.
Puedes ver las versiones de la instancia en la página Detalles de la instancia de la IU de Apigee en la consola de Google Cloud . Ve a la página Instancias en la consola de Google Cloud para seleccionar una instancia y ver sus detalles:
Ir a Instancias

Puedes usar Extension Processor con una organización de Apigee de suscripción o de Pay-as-you-go. Si no sabes con certeza si usas una organización de suscripción de Apigee o de pago por uso, comunícate con el administrador de tu organización de Apigee. Para obtener más detalles sobre el aprovisionamiento de instancias pagadas de Apigee, consulta Antes de comenzar.
Confirma que tienes habilitada una VPC y una subred en la instancia de Apigee que planeas usar. Ve a la página Redes de VPC en la consola de Google Cloud :
Ir a Redes de VPC

Roles requeridos

Para obtener los permisos que necesitas para instalar el procesador de extensiones de Apigee, pídele a tu administrador que te otorgue los siguientes roles de IAM en la organización:

Crear y administrar cuentas de servicio: Administrador de cuentas de servicio (roles/iam.serviceAccountAdmin)
Crear y administrar extensiones del servicio: Administrador de extensiones del servicio (roles/networkservices.serviceExtensionsAdmin)
Crear y administrar grupos de extremos de red (NEG): Administrador de instancias de Compute (roles/compute.instanceAdmin)
Crear y administrar recursos de redes: Administrador de red de Compute (roles/compute.networkAdmin)
Crear y administrar servicios de backend: Administrador de balanceador de cargas de Compute (roles/compute.loadBalancerAdmin)
Crear y administrar recursos de Apigee: Administrador de la organización de Apigee (roles/apigee.admin)

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Configure las variables de entorno

En el proyecto Google Cloud que contiene tu instancia de Apigee, usa el siguiente comando para configurar las variables de entorno:

export PROJECT_ID=PROJECT_ID
export ORG_NAME=$PROJECT_ID
export REGION=REGION
export INSTANCE=INSTANCE
export VPC_NETWORK_NAME=VPC_NETWORK_NAME
export SUBNET=SUBNET

Aquí:

PROJECT_ID es el ID del proyecto con tu instancia de Apigee.
REGION es la Google Cloud región de tu instancia de Apigee.
INSTANCE es el nombre de tu instancia de Apigee.
VPC_NETWORK_NAME es el nombre de la red de VPC en tu proyecto Google Cloud que deseas usar para el Apigee Extension Processor.
SUBNET es el nombre de la subred de tu proyecto Google Cloud que deseas usar para el Apigee Extension Processor.

Para confirmar que las variables de entorno estén configuradas correctamente, ejecuta el siguiente comando y revisa el resultado:

echo $PROJECT_ID $ORG_NAME $REGION $INSTANCE $VPC_NETWORK_NAME $SUBNET

Configura un token de autenticación

Para configurar un token de autenticación, ejecuta el siguiente comando:

export TOKEN=$(gcloud auth print-access-token)
echo $TOKEN

Configura un balanceador de cargas para un servicio de backend

En las siguientes secciones, se describen los pasos necesarios para configurar un balanceador de cargas de aplicaciones externo global para un servicio de backend, con httpbin.org como ejemplo:

Crea un balanceador de cargas de aplicaciones externo global.
Crea un grupo de extremos de red (NEG).
Crea un servicio de backend.
Crea un mapa de URL.
Crea un proxy de destino.
Crea una regla de reenvío global.

Crea un balanceador de cargas de aplicaciones externo global

Para crear el balanceador de cargas, sigue estos pasos:

Configura gcloud para usar tu proyecto actual:
```
gcloud config set project PROJECT_ID
```
Aquí, PROJECT_ID es el ID del proyecto con tu instancia de Apigee.
Crea una dirección IP estática global:
```
gcloud compute addresses create IP_ADDRESS --ip-version=IPV4 --global
```
Aquí, IP_ADDRESS es el nombre de la dirección IP que deseas crear. El nombre debe coincidir con la expresión regular (?:a-z?).
Obtén la dirección IP y guárdala como una variable de entorno:
```
IP=$(gcloud compute addresses describe IP_ADDRESS --format="get(address)" --global)
```
Aquí, IP_ADDRESS es el nombre de la dirección IP que creaste en el paso anterior.
Crea un certificado TLS para nip.io, un servicio de terceros que proporciona registros DNS comodín para direcciones IP:
```
gcloud compute ssl-certificates create SSL_CERT_NAME \
  --domains="nip.io"
```
Aquí, SSL_CERT_NAME es el nombre del certificado que deseas crear.

Crea un grupo de extremos de red (NEG)

Sigue estos pasos para crear el grupo de extremos de red (NEG) para tu balanceador de cargas:

Crea un NEG:

gcloud compute network-endpoint-groups create NEG_NAME \
  --network-endpoint-type=INTERNET_FQDN_PORT \
  --default-port=443 \
  --global

Aquí, NEG_NAME es el nombre del NEG que deseas crear.

Agrega el extremo de httpbin.org al NEG:

gcloud compute network-endpoint-groups update NEG_NAME \
  --add-endpoint=fqdn=httpbin.org,port=443 \
  --global

Aquí, NEG_NAME es el nombre del NEG que creaste en el paso anterior.

Crear un servicio de backend

Para crear el servicio de backend expuesto por el balanceador de cargas, haz lo siguiente:

Crea el servicio de backend:

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

Aquí, BACKEND_SERVICE_NAME es el nombre del servicio de backend que deseas crear.

Agrega el NEG al backend:
```
gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --network-endpoint-group=NEG_NAME \
  --global-network-endpoint-group \
  --global
```
Aquí:
- BACKEND_SERVICE_NAME es el nombre del servicio de backend que creaste en el paso anterior.
- NEG_NAME es el nombre del NEG que creaste en un paso anterior.

Crear un mapa de URL

Para crear un mapa de URL entre el balanceador de cargas y el servicio de backend, usa el siguiente comando:

gcloud compute url-maps create URL_MAP_NAME \
  --default-service BACKEND_SERVICE_NAME \
  --global

Aquí:

URL_MAP_NAME es el nombre del mapa de URL que deseas crear.
BACKEND_SERVICE_NAME es el nombre del servicio de backend que creaste en un paso anterior.

Crea un proxy de destino

Para crear un proxy de destino para el balanceador de cargas, usa el siguiente comando:

gcloud compute target-https-proxies create TARGET_PROXY_NAME \
  --global \
  --ssl-certificates SSL_CERT_NAME \
  --global-ssl-certificates \
  --url-map URL_MAP_NAME \
  --global-url-map

Aquí:

TARGET_PROXY_NAME es el nombre del proxy de destino que deseas crear.
URL_MAP_NAME es el nombre del mapa de URL que creaste en un paso anterior.
SSL_CERT_NAME es el nombre del certificado SSL que creaste para nip.io en un paso anterior.

Crear una regla de reenvío global

Para crear una regla de reenvío global para el balanceador de cargas, usa el siguiente comando:

gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --network-tier=PREMIUM \
  --address=IP_ADDRESS \
  --target-https-proxy=TARGET_PROXY_NAME \
  --ports=443 \
  --global

Aquí:

FORWARDING_RULE_NAME es el nombre de la regla de reenvío que deseas crear.
IP_ADDRESS es el nombre de la dirección IP del extremo del NEG que creaste en un paso anterior.
TARGET_PROXY_NAME es el nombre del proxy de destino que creaste en un paso anterior.

Configura el procesador de extensiones de Apigee

En las siguientes secciones, se describen los pasos necesarios para configurar el procesador de extensiones de Apigee:

Crea un entorno de Apigee.
Crea el proxy del procesador de extensiones.

Crea un entorno de Apigee

Crea un entorno de Apigee con el siguiente comando:

curl -i -X POST -H  "Authorization: Bearer $TOKEN" \
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/environments" -H "Content-Type:application/json" -d \
    '{
        "name": "ENV_NAME",
        "displayName": "ENV_NAME",
        "state": "ACTIVE",
        "deploymentType": "PROXY",
        "apiProxyType": "PROGRAMMABLE",
        "type": "COMPREHENSIVE",
        "properties":
        {"property": [
            {
            "name": "apigee-service-extension-enabled",
            "value": "true"
            }
          ]
        }
    }'

En el ejemplo anterior, ENV_NAME es el nombre del entorno que crearás. El nombre debe contener entre 2 y 32 caracteres, que pueden ser letras minúsculas, números o guiones. El nombre debe comenzar con una letra y no puede terminar con un guion. El nombre debe ser diferente de cualquier otro nombre de entorno en tu organización.

Confirma que se haya creado el entorno:

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

La lista de entornos debe incluir el que acabas de crear.

Adjunta el entorno recién creado a tu instancia de Apigee:

curl -i -X POST -H "Authorization: Bearer $TOKEN" \
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/instances/$INSTANCE/attachments" -H "Content-Type:application/json" -d \
    '{
        "environment": "ENV_NAME"
        }'

Aquí, ENV_NAME es el nombre del entorno que creaste en el paso anterior.

Esta operación puede tardar hasta 10 minutos.

Crea el grupo de entornos de Apigee:
```
curl -H "Authorization: Bearer $TOKEN" -X POST \
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/envgroups" -H "Content-Type:application/json" -d \
    '{
        "name": "ENV_GROUP_NAME",
        "hostnames": ["ENV_GROUP_HOSTNAME"]
        }'
```
Aquí:
- ENV_GROUP_NAME es el nombre del grupo de entornos que estás creando.
- ENV_GROUP_HOSTNAME es el nombre de host del grupo de entornos que estás creando. El nombre de host debe ser un nombre de dominio completamente calificado (FQDN).
  Nota: No es necesario que se pueda resolver el nombre de host.

Conecta el entorno nuevo al grupo de entornos nuevo:

curl -H "Authorization: Bearer $TOKEN" -X POST\
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/envgroups/ENV_GROUP_NAME/attachments" -H "content-type:application/json" -d \
        '{
            "name": "ENV_GROUP_NAME",
            "environment": "ENV_NAME"
        }'

Aquí:

ENV_GROUP_NAME es el nombre del grupo de entornos que estás creando.
ENV_NAME es el nombre del entorno que creaste en un paso anterior.

Crea el proxy del procesador de extensiones

El proxy de Extension Processor es un proxy de API de Apigee que se usa para aplicar políticas de administración de APIs al tráfico del balanceador de cargas. Puedes crear un proxy sin destino o un proxy habilitado para eventos enviados por el servidor (SSE). Para obtener más información sobre el uso de SSE con Apigee, consulta Eventos enviados por el servidor.

Para crear un proxy de API de Apigee para usarlo con el balanceador de cargas de Extension Processor, haz lo siguiente:

Sin proxy de destino

Sigue los pasos que se indican en Cómo crear un proxy de API para crear un proxy Sin destino con las siguientes especificaciones:

Plantilla de proxy: Selecciona Sin destino.
Nombre del proxy: Ingresa un nombre para el proxy.
Ruta base: Establece la ruta base que desees. No se usará la ruta.

La especificación XML del proxy debería ser similar a la siguiente:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<APIProxy revision="1" name="extproc-sample">
    <DisplayName/>
    <Description/>
    <CreatedAt>1739581781912</CreatedAt>
    <LastModifiedAt>1739582447868</LastModifiedAt>
    <BasePaths>/</BasePaths>
    <Policies></Policies>
    <ProxyEndpoints>
        <ProxyEndpoint>default</ProxyEndpoint>
    </ProxyEndpoints>
</APIProxy>

Sigue los pasos que se indican en Implementa un proxy de API para implementar el proxy en el entorno que creaste antes.

Proxy habilitado para SSE

Sigue los pasos que se indican en Cómo crear un proxy de API para crear un proxy de eventos enviados por el servidor con las siguientes especificaciones:

Plantilla de proxy: Selecciona Sin destino.
Nombre del proxy: Ingresa un nombre para el proxy.
Ruta base: Establece la ruta base que desees. No se usará la ruta.

La especificación XML del proxy debería ser similar a la siguiente:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<APIProxy revision="1" name="extproc-sample">
    <DisplayName/>
    <Description/>
    <CreatedAt>1739581781912</CreatedAt>
    <LastModifiedAt>1739582447868</LastModifiedAt>
    <BasePaths>/</BasePaths>
    <ProxyEndpoints>
        <ProxyEndpoint>default</ProxyEndpoint>
    </ProxyEndpoints>
</APIProxy>

Configura EventFlow en el proxy:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<APIProxy revision="1" name="extproc-sample">
    <DisplayName/>
    <Description/>
    <CreatedAt>1739581781912</CreatedAt>
    <LastModifiedAt>1739582447868</LastModifiedAt>
    <BasePaths>/</BasePaths>
    <ProxyEndpoints>
        <ProxyEndpoint>default</ProxyEndpoint>
        <EventFlow name="EventFlow" content-type="text/event-stream">
          <Response/>
        </EventFlow>
        <HTTPProxyConnection>
          <Properties/>
          <URL>https://httpbin.org/sse</URL>
        </HTTPProxyConnection>
    </ProxyEndpoints>
</APIProxy>

Sigue los pasos que se indican en Implementa un proxy de API para implementar el proxy en el entorno que creaste antes.

Configura la extensión de tráfico

En esta sección, se describe cómo configurar la extensión del servicio de tráfico para tu procesador de extensiones con los siguientes pasos:

Crea un grupo de extremos de red de Apigee Private Service Connect.
Crea una extensión de servicio de balanceador de cargas.
Envía una solicitud al balanceador de cargas.

Crea un grupo de extremos de red de Private Service Connect de Apigee

En esta sección, crearás un grupo de extremos de red (NEG) de Private Service Connect (PSC) de Apigee que se usa para conectarse a tu instancia de Apigee. Para obtener más información sobre PSC, consulta Patrones de herramientas de redes descendentes.

Nota: El comando para obtener el adjunto de servicio de PSC de Apigee requiere jq. Si esta utilidad de procesamiento de JSON aún no está instalada en tu entorno de desarrollo, puedes instalarla con el siguiente comando: $ sudo apt install jq.

Para crear un NEG de PSC de Apigee, haz lo siguiente:

Obtén el adjunto de servicio de PSC de Apigee:

PSC_ATTACHMENT=$(curl -s -H "Authorization: Bearer $TOKEN" \
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/instances" \
    | jq -r '.instances[] | select(.name = "'$INSTANCE'") | .serviceAttachment' \
    )

Para ver el adjunto del servicio, haz lo siguiente:

echo $PSC_ATTACHMENT

La respuesta debería ser similar a la siguiente:

projects/apigee-psc-autopush/regions/us-west1/serviceAttachments/apigee-us-west1-1234567890-psc-service-attachment

Crea el NEG de PSC en la misma región que tu instancia de Apigee:

gcloud compute network-endpoint-groups create apigee-neg-$REGION \
  --network-endpoint-type=private-service-connect \
  --psc-target-service=$PSC_ATTACHMENT \
  --region=$REGION \
  --network=$VPC_NETWORK_NAME \
  --subnet=$SUBNET

La respuesta debería ser similar a la siguiente:

projects/ab123456cd78ef910g-tp/regions/asia-northeast1/serviceAttachments/apigee-asia-northeast1-abcd

Crea un servicio de backend HTTP/2 que apunte al NEG de PSC, si aún no existe uno:
```
gcloud compute backend-services create PSC_NEG_BACKEND_SERVICE \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --protocol=HTTP2 \
  --global
```
Aquí, PSC_NEG_BACKEND_SERVICE es el nombre del servicio de backend que deseas crear.

Agrega el servicio de backend del NEG de PSC:

gcloud compute backend-services add-backend PSC_NEG_BACKEND_SERVICE \
  --network-endpoint-group=apigee-neg-$REGION \
  --network-endpoint-group-region=$REGION \
  --global

Aquí, PSC_NEG_BACKEND_SERVICE es el nombre del servicio de backend que creaste en un paso anterior.

Habilita el registro para el servicio de backend:
```
gcloud compute backend-services update PSC_NEG_BACKEND_SERVICE \
  --global \
  --enable-logging \
  --logging-sample-rate=1.0
```
Aquí, PSC_NEG_BACKEND_SERVICE es el nombre del servicio de backend que creaste en un paso anterior.

Crea una extensión de servicio del balanceador de cargas

Cuando creas una extensión de servicio del balanceador de cargas, puedes personalizar el comportamiento del proxy del procesador de extensiones cambiando los valores de varios campos que describen la extensión, como se muestra en la siguiente tabla:

Procesamiento del cuerpo Eventos admitidos Metadatos Modo de envío

Procesamiento del cuerpo de la solicitud y la respuesta

Procesamiento del cuerpo	Eventos admitidos	Metadatos	Modo de envío
Procesamiento del cuerpo de la solicitud y la respuesta	`REQUEST_HEADERS` `REQUEST_BODY` `REQUEST_TRAILERS` `RESPONSE_HEADERS` `RESPONSE_BODY` `RESPONSE_TRAILERS`	`apigee-request-body: true` `apigee-response-body: true`	`requestBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED` `responseBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED`
Solo se procesa el cuerpo de la solicitud	`REQUEST_HEADERS` `REQUEST_BODY` `REQUEST_TRAILERS` `RESPONSE_HEADERS`	`apigee-request-body: true`	`requestBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED`
Solo se procesa el cuerpo de la respuesta	`REQUEST_HEADERS` `RESPONSE_HEADERS` `RESPONSE_BODY` `RESPONSE_TRAILERS`	`apigee-response-body: true`	`responseBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED`

REQUEST_HEADERS

REQUEST_BODY

REQUEST_TRAILERS

RESPONSE_HEADERS

RESPONSE_BODY

RESPONSE_TRAILERS

apigee-request-body: true

apigee-response-body: true

requestBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED

responseBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED

Solo se procesa el cuerpo de la solicitud

REQUEST_HEADERS

REQUEST_BODY

REQUEST_TRAILERS

RESPONSE_HEADERS

apigee-request-body: true

requestBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED

Solo se procesa el cuerpo de la respuesta

REQUEST_HEADERS

RESPONSE_HEADERS

RESPONSE_BODY

RESPONSE_TRAILERS

apigee-response-body: true

responseBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED

En este paso, crearás una extensión de servicio del balanceador de cargas que admita el procesamiento del cuerpo de la solicitud y la respuesta:

curl -X POST "https://networkservices.googleapis.com/v1beta1/projects/$PROJECT_ID/locations/global/lbTrafficExtensions?lbTrafficExtensionId=global-xlb-httpbin-apim-policy" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "global-xlb-httpbin-apim-policy",
    "forwardingRules": [
        "https://www.googleapis.com/compute/v1/projects/$PROJECT_ID/global/forwardingRules/FORWARDING_RULE_NAME"
    ],
    "extensionChains": [
        {
            "name": "httpbin-apigee-extension-chain",
            "matchCondition": {
                "celExpression": "true"
            },
            "extensions": [
                {
                    "name": "httpbin-apigee-extension",
                    "authority": "ENV_GROUP_HOSTNAME",
                    "service": "https://www.googleapis.com/compute/v1/projects/$PROJECT_ID/global/backendServices/PSC_NEG_BACKEND_SERVICE",
                    "supportedEvents": [
                        "REQUEST_HEADERS",
                        "REQUEST_BODY",
                        "REQUEST_TRAILERS",
                        "RESPONSE_HEADERS",
                        "RESPONSE_BODY",
                        "RESPONSE_TRAILERS"
                    ],
                    "timeout": "1s",
                    "requestBodySendMode": "BODY_SEND_MODE_FULL_DUPLEX_STREAMED",
                    "responseBodySendMode": "BODY_SEND_MODE_FULL_DUPLEX_STREAMED"
                }
            ]
        }
    ],
    "loadBalancingScheme": "EXTERNAL_MANAGED",
    "metadata": {
        "apigee-extension-processor": "EXT_PROC_NAME",
        "apigee-request-body": "true",
        "apigee-response-body": "true"
    }
}'

Aquí:

EXT_PROC_NAME Este nombre debe coincidir con el nombre del proxy de API que creaste en un paso anterior.
FORWARDING_RULE_NAME es el nombre de la regla de reenvío que creaste en un paso anterior.
ENV_GROUP_HOSTNAME es el nombre de dominio que se usa para el grupo de entornos.
PSC_NEG_BACKEND_SERVICE es el nombre del servicio de backend que creaste en un paso anterior.

Esta operación puede tardar unos minutos en completarse.

Para confirmar que se creó la extensión de servicio, usa el siguiente comando:

curl "https://networkservices.googleapis.com/v1beta1/projects/$PROJECT_ID/locations/global/lbTrafficExtensions/httpbin-apigee-extension" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json"

La respuesta debería ser similar a la siguiente y mostrar la regla de reenvío y el servicio de backend:

createTime: '2025-03-22T00:29:16.056719825Z'
extensionChains:
- extensions:
  - authority: extension-processor-test.hybrid.e2e.apigeeks.net
    name: httpbin-apigee-extension
    service: https://www.googleapis.com/compute/v1/projects/123456789012/global/backendServices/ep-test-psc-neg-bes
    supportedEvents:
    - REQUEST_HEADERS
    - REQUEST_BODY
    - REQUEST_TRAILERS
    - RESPONSE_HEADERS
    - RESPONSE_BODY
    - RESPONSE_TRAILERS
    timeout: 1s
  matchCondition:
    celExpression: 'true'
  name: httpbin-apigee-extension-chain
forwardingRules:
- https://www.googleapis.com/compute/v1/projects/123456789012/global/forwardingRules/ep-test-fw-rule
loadBalancingScheme: EXTERNAL_MANAGED
metadata:
  apigee-extension-processor: ep-test-proxy
  apigee-request-body: true
  apigee-response-body: true
name: projects/extension-processor-test/locations/global/lbTrafficExtensions/global-xlb-httpbin-apim-policy
updateTime: '2025-03-22T00:29:31.183275055Z'

Envía una solicitud al balanceador de cargas

Para probar la configuración del balanceador de cargas y del procesador de extensiones, envía una solicitud al balanceador de cargas:

curl "https://LB_DOMAIN_NAME/get"

Aquí LB_DOMAIN_NAME es el nombre de dominio que usaste para el balanceador de cargas y el certificado SSL. Si usaste nip.io, el nombre de dominio se verá similar a IP_ADDRESS.nip.io.

La respuesta debería ser similar a la siguiente:

{"status": 200,
  {
    "args": {},
    "headers": {
      ...
    },
    "origin": "173.93.50.108",
    "url": "https://httpbin.org/get"
  }
}

Usa políticas con el procesador de extensiones

En esta sección, se describe cómo usar políticas con Extension Processor.

En este ejemplo, se configuran una política VerifyAPIkey y una política AssignMessage para el Extension Processor. Estas políticas se usan para validar las claves de API incluidas en las solicitudes a Apigee y para insertar un token de Googleen los encabezados de las solicitudes para las llamadas a un servicio de backend. Este caso de uso sería útil para los proveedores de APIs que usan el procesador de extensiones de Apigee para autorizar y autenticar solicitudes a sus servicios de Apigee, y para insertar sin problemas los tokens de autorización deGoogle necesarios para un servicio de backend como Vertex AI.

Agrega la política VerifyAPIKey para la validación de la clave de API

En las siguientes secciones, se describe cómo usar la política VerifyAPIKey para validar las claves de API de las llamadas a tu servicio de backend con el procesador de extensiones:

Adjunta la política VerifyAPIKey al Extension Processor.
Crea un producto de API.
Crea una app para desarrolladores y credenciales de la app.
Envía una solicitud al balanceador de cargas con la clave de API.

Adjunta la política VerifyAPIKey al proxy

Para adjuntar una política de VerifyAPIKey al proxy de Extension Processor, haz lo siguiente:

En la Google Cloud consola, ve a la página Proxy Development > API Proxies.

Ir a Proxies de API
Selecciona el proxy de Extension Processor que creaste en la sección Crea un procesador de extensiones.
Haz clic en la pestaña Desarrollar:
En el panel de navegación, haz clic en en la sección Políticas.
En el cuadro de diálogo Crear política, selecciona VerifyAPIKey en la lista de políticas.
En el panel VerifyAPIKey, completa los campos obligatorios en las secciones Nombre y Nombre visible con los siguientes valores:
- Nombre: Ingresa un nombre para la política. Por ejemplo, VA-verify-api-key
- Nombre visible: Ingresa el nombre de la política para usarlo en la IU. Por ejemplo, VA-verify-api-key

Haz clic en Crear.

La especificación XML de la política VerifyAPIKey incluida en el proxy de Extension Processor debería ser similar a la siguiente:

  <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  <VerifyAPIKey continueOnError="false" enabled="true" name="VA-verify-api-key">
    <DisplayName>VA-verify-api-key</DisplayName>
    <Properties/>
    <APIKey ref="request.queryparam.x-api-key"/>
  </VerifyAPIKey>

Implementa la revisión nueva del proxy.

Crear un producto de API

Para crear un producto de API y configurar el conjunto de operaciones de la API para tu servicio, haz lo siguiente:

Sigue los pasos que se indican en Cómo crear un producto de API para crear un producto de API para tu servicio. Puedes configurar los detalles del producto del producto de API como desees.
Sigue los pasos que se indican en Operaciones para agregar un conjunto de operaciones de API al producto de API, según las siguientes especificaciones:
- Fuente:
  En la Google Cloud consola, ve a la página Distribución > Productos de API.
  
  Ir a Productos de API
  Selecciona el producto de API que creaste en un paso anterior.
- Operación: Haz clic en Editar y configura las siguientes rutas y métodos:
  - Ruta de acceso: /get con el método: GET
  - Ruta de acceso: /PROXY_NAME con el método: GET
    PROXY_NAME es el nombre del proxy que creaste en un paso anterior.

Crea una app de desarrollador y credenciales de la app

Para crear una app para desarrolladores y credenciales de la app para el producto de API recién creado, haz lo siguiente:

Ve a la página Administración de la API de Apigee en la consola de Google Cloud :
Administración de API de Apigee
Crea un desarrollador:
1. Selecciona Distribución > Desarrolladores.
2. En la página Desarrolladores, haz clic en + Crear.
3. En la página Agregar desarrollador, completa los campos obligatorios con los valores que desees.
4. Haz clic en Agregar.
Crea una app:
1. Selecciona Distribución> Apps.
2. En la página Apps, haz clic en + Crear.
3. En la página Create App, completa los campos obligatorios de la sección App Details con los siguientes valores:
  - Nombre de la app: Ingresa un nombre para la app. Por ejemplo, ext-proc-app.
  - Desarrollador: Selecciona el desarrollador que creaste en el paso anterior o cualquier otro desarrollador de la lista.
4. En la sección Credenciales de la app, haz clic en + Agregar credencial.
5. En la sección Credencial, selecciona Nunca en el cuadro de lista Vencimiento.
6. En la sección Productos, haz clic en + Agregar productos para mostrar el panel Agregar productos.
7. Selecciona el producto de API que creaste en el paso anterior.
8. Haz clic en Aceptar.
9. Haz clic en Agregar para cerrar el panel Agregar productos.
10. Haz clic en Crear.
En la página App Details, en la sección Credential, haz clic en para mostrar el valor de la Key.
Copia el valor de Key. Usarás esta clave para realizar llamadas a la API de tu servicio en un paso posterior.
En la página App Details, en la sección Credential, haz clic en para mostrar el valor de App Secret.

Envía una solicitud al balanceador de cargas con la clave de API

Para probar la validación de la clave de API, envía una solicitud al balanceador de cargas con la clave de API:

curl "https://LB_DOMAIN_NAME/get"

Aquí LB_DOMAIN_NAME es el nombre de dominio que usaste para el balanceador de cargas y el certificado SSL.

La respuesta debería fallar sin una clave de API.

Envía otra solicitud al balanceador de cargas con la clave de API en la solicitud:

curl "https://LB_DOMAIN_NAME/get?key=API_KEY"

Aquí:

LB_DOMAIN_NAME es el nombre de dominio que usaste para el balanceador de cargas y el certificado SSL.
API_KEY es la clave de API de las credenciales de la app para desarrolladores que se revelaron en un paso anterior.

La respuesta debe indicar que se autorizó correctamente el extremo. Esto indica que el procesador de extensiones validó la clave de API y que el proxy de Apigee ahora puede procesar la solicitud.

Agrega la política AssignMessage para la Google autenticación

Si deseas usar tu Extension Processor para proporcionar administración de APIs para un servicio autenticado por Google, puedes insertar un token de acceso de Google o un token de ID de Google en las solicitudes enviadas al servicio de backend con la política AssignMessage.

En las siguientes secciones, se describe cómo usar la política AssignMessage para insertar un token de autenticación Google en las solicitudes enviadas al servicio de backend con el procesador de extensiones:

Adjunta la política AssignMessage al proxy.
Envía una solicitud al balanceador de cargas para probar la inserción de tokens.

Adjunta la política AssignMessage al proxy

Para agregar la política de AssignMessage a tu proxy, haz lo siguiente:

En la Google Cloud consola, ve a la página Proxy Development > API Proxies.

Ir a Proxies de API
Selecciona el proxy de Extension Processor que creaste en la sección Crea un procesador de extensiones.
Haz clic en la pestaña Desarrollar:
En el panel de navegación, haz clic en en la sección Políticas.
En el diálogo Crear política, selecciona AssignMessage en la lista de políticas.
En el panel Asignar mensaje, completa los campos obligatorios en las secciones Nombre y Nombre visible con los siguientes valores:
- Nombre: Ingresa un nombre para la política. Por ejemplo, AM-auth
- Nombre visible: Ingresa un nombre de política para mostrar en la IU. Por ejemplo, AM-auth
Haz clic en Crear.

Debajo del elemento <Set>, agrega los siguientes elementos secundarios:

<Set>
    <Authentication>
    <HeaderName>Authorization</HeaderName>
    <GoogleAccessToken>
        <Scopes>
        <Scope>https://www.googleapis.com/auth/cloud-platform</Scope>
        </Scopes>
    </GoogleAccessToken>
    </Authentication>
</Set>

Haz clic en Guardar.
Implementa la revisión nueva con una cuenta de servicio Google .

La cuenta de servicio se usa para generar tokens de acceso Google y, luego, insertarlos en el encabezado de la solicitud para las llamadas a la API de los servicios de backend Google .

Envía una solicitud al balanceador de cargas para probar la inserción de tokens

Para confirmar que la inserción de tokens funciona, envía una solicitud al balanceador de cargas:

curl "https://LB_DOMAIN_NAME/get"

Aquí LB_DOMAIN_NAME es el nombre de dominio que usaste para el balanceador de cargas y el certificado SSL.

La respuesta debería ser similar a la siguiente:

{
  ...
  "headers": {
    "Accept": "*/*",
    "Authorization": "Bearer ya29.c.c0ASRK0Gbw03y9cfvxL11DxaRYBQUU18SmUP4Vu63OckHI5cX7wJ4DmGMG2vbDDS69HXJHqMj-lak4tcqOsJGmE65crn2gNuJLanXidwM8",
    "First": "1.0",
    "Host": "apigee-ext-proc-test.apigee.net",
    "Second": "1.0",
    "Sum": "2",
    "User-Agent": "curl/8.7.1",
    "X-Api-Key": "McYcHGR3PTSGLXExvKADwQ1JJeCjgPDUvAakCl0rJKCFaX0Y",
    "X-Cloud-Trace-Context": "0fd3dadc2a3c328fa968d5f5f1434c29/18300783092696918345"
  },
  ...
}

La respuesta debe mostrar la inserción correcta del token de autenticación Google en el encabezado de la solicitud.

Con la aplicación exitosa de la política AssignMessage, la solicitud exitosa del cliente (que contiene la clave de API) a Apigee en la situación de ejemplo se modifica aún más para incluir un token de autenticación de Google en el encabezado de la solicitud, según lo requiere el servicio de backend autenticado con Google.

Comienza a usar el procesador de extensiones de Apigee Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Antes de comenzar

Roles requeridos

Configure las variables de entorno

Configura un token de autenticación

Configura un balanceador de cargas para un servicio de backend

Crea un balanceador de cargas de aplicaciones externo global

Crea un grupo de extremos de red (NEG)

Crear un servicio de backend

Crear un mapa de URL

Crea un proxy de destino

Crear una regla de reenvío global

Configura el procesador de extensiones de Apigee

Crea un entorno de Apigee

Crea el proxy del procesador de extensiones

Sin proxy de destino

Proxy habilitado para SSE

Configura la extensión de tráfico

Crea un grupo de extremos de red de Private Service Connect de Apigee

Crea una extensión de servicio del balanceador de cargas

Envía una solicitud al balanceador de cargas

Usa políticas con el procesador de extensiones

Agrega la política VerifyAPIKey para la validación de la clave de API

Adjunta la política VerifyAPIKey al proxy

Crear un producto de API

Crea una app de desarrollador y credenciales de la app

Envía una solicitud al balanceador de cargas con la clave de API

Agrega la política AssignMessage para la Google autenticación

Adjunta la política AssignMessage al proxy

Envía una solicitud al balanceador de cargas para probar la inserción de tokens

Comienza a usar el procesador de extensiones de Apigee