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

Agrega políticas a la puerta de enlace de GKE

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

Consulta la documentación de Apigee Edge.

En esta página, se describe cómo agregar políticas de tiempo de ejecución de Apigee y una Google política de inserción de tokens a la puerta de enlace de Google Kubernetes Engine (GKE) con el operador de APIM de Apigee para Kubernetes (versión preliminar). Agregar un conjunto disponible de políticas a la puerta de enlace te permite extender su funcionalidad más allá de la aplicación forzosa de productos de API para incluir reglas comerciales y de seguridad adicionales.

El operador de APIM de Apigee para Kubernetes se puede usar para agregar las siguientes políticas a la puerta de enlace:

Descripción general

En las secciones que aparecen a continuación, se describe cómo realizar las siguientes tareas:

Agrega políticas a la puerta de enlace de GKE.
Crea una regla de plantilla para aplicar el uso de las políticas.
Actualiza la plantilla de Apigee para incluir la regla de plantilla .

Implementa la política de Apigee Gateway con la plantilla.
Valida la aplicación de políticas.

Antes de comenzar

Para modificar tu puerta de enlace de GKE con el conjunto completo de políticas que se usan como ejemplo en esta guía, debes tener una cuenta de servicio con los roles necesarios para crear tokens en Apigee y, luego, implementar proxies y extensiones. Si eliges no crear tokens de Google , no es necesario que agregues los roles adicionales a tu cuenta de servicio y puedes avanzar a la siguiente sección.

Para crear una cuenta de servicio con los permisos requeridos, sigue estos pasos:

Si creaste una cuenta de servicio llamada apigee-apim-gsa en la guía de instalación del operador de APIM de Apigee para Kubernetes, puedes omitir este paso y continuar con el siguiente. De lo contrario, crea la cuenta de servicio:
```
gcloud iam service-accounts create apigee-apim-gsa --project=${PROJECT_ID}
```

Otorga a la cuenta de servicio el rol necesario para crear tokens:

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member "serviceAccount:apigee-apim-gsa@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role "roles/iam.serviceAccountTokenCreator"

Otorga a la cuenta de servicio apigee-apim-gsa el rol necesario para implementar proxies y extensiones:

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member "serviceAccount:apigee-apim-gsa@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role "roles/iam.serviceAccountUser"

Modifica tu puerta de enlace de GKE con políticas

Puedes modificar tu puerta de enlace de GKE con una o más políticas para extender su funcionalidad. En esta explicación de ejemplo, se aplica un archivo yaml a la puerta de enlace que incluye las especificaciones de dos políticas de Apigee y una Google política de inserción de tokens.

Cada una de las políticas aplicadas a la puerta de enlace con el siguiente archivo yaml realiza una función diferente cuando se evalúan las solicitudes que se envían a la puerta de enlace:

La política de SpikeArrest controla la tasa máxima de mensajes definiendo una tasa máxima de solicitudes permitidas en una unidad de tiempo. En este ejemplo, la frecuencia máxima se establece en cinco por minuto. Para obtener más información sobre cómo se usa la política de SpikeArrest para suavizar los aumentos repentinos en el tráfico, consulta la política de SpikeArrest.
La política de JavaScript te permite agregar código JavaScript personalizado a las solicitudes de la puerta de enlace. En este ejemplo, se usa la política para agregar un encabezado personalizado a la solicitud. Para obtener más información sobre cómo se usa la política de JavaScript para agregar código personalizado, consulta Política de JavaScript.
La Google política de inserción de tokens se usa para insertar un Google token de acceso de autenticación en las solicitudes de la puerta de enlace con la política AssignMessage. Apigee admite el uso de Google tokens de OAuth o tokens de OpenID Connect para autenticar con Google servicios. Para obtener más información sobre los tokens de autenticación, consulta Cómo usar la autenticación de Google.

Agrega las políticas a la puerta de enlace:

Crea un archivo nuevo llamado apigee-policies.yaml en el espacio de nombres apim.

Copia el contenido del siguiente archivo en el archivo nuevo que creaste:

# apigee-policies.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: SpikeArrest
metadata:
  name: spike-arrest
  namespace: apim
spec:
  identifier:
    ref: request.header.name
  useEffectiveCount: true
  peakMessageRate:
    value: "5pm"
---
apiVersion: apim.googleapis.com/v1alpha1
kind: Javascript
metadata:
  name: js-add-headers
  namespace: apim
spec:
  timeLimit: 2000
  source: |
    var sum = 1+1;
    context.setVariable("request.header.first", 1);
    context.setVariable("request.header.second", 1);
    context.setVariable("request.header.sum", sum);
---
apiVersion: apim.googleapis.com/v1alpha1
kind: AssignMessage
metadata:
  name: google-token-policy
  namespace: apim
spec:
  setActions:
    - authentication:
        googleAccessToken:
          scopes:
            - 'https://www.googleapis.com/auth/cloud-platform'
  AssignTo:
    createNew: false
    type: request

Aplica el archivo yaml a la puerta de enlace con el siguiente comando:
```
kubectl -n apim apply -f apigee-policies.yaml
```

Crea una TemplateRule como plantilla de SharedFlow

En este paso, crearás un TemplateRule para aplicar las políticas que agregaste a la puerta de enlace. Una regla de plantilla es una regla para SharedFlows que crean los administradores de la organización para garantizar que los desarrolladores de servicios apliquen solo políticas aprobadas al tráfico de la puerta de enlace. Una regla de plantilla garantiza que los desarrolladores comprendan qué políticas tienen disponibles, cuáles son obligatorias para casos de uso específicos y cuáles no pueden usar los desarrolladores de servicios.

Crea una regla de plantilla

Crea una regla de plantilla para aplicar el uso de la política AssignMessage:

Crea un nuevo archivo yaml llamado template-rule.yaml en el espacio de nombres apim.
Copia el contenido del siguiente archivo en el archivo nuevo que creaste:
```
# template-rule.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: ApimTemplateRule
metadata:
  name: template-rule
  namespace: apim
spec:
  allowList: [SpikeArrest, Javascript]
  requiredList: [AssignMessage]
  denyList: []
```
En este ejemplo, la regla de plantilla les indica a los desarrolladores que se requiere la política de AssignMessage que describe la política de Google de inserción de tokens. También les indica a los desarrolladores que pueden usar las políticas de SpikeArrest y JavaScript en su administración de APIs. No se especifican políticas en la lista de rechazo.

Aplica la regla de plantilla

Aplica la regla de plantilla con el siguiente comando:

kubectl apply -f template-rule.yaml

Actualiza la plantilla de Apigee para incluir las reglas de la plantilla

Actualiza la plantilla de Apigee para incluir la regla de plantilla que creaste en la sección anterior:

Crea un nuevo archivo yaml llamado new-admin-template.yaml en el espacio de nombres apim.

Copia el contenido del siguiente archivo en el archivo nuevo que creaste:

# new-admin-template.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: ApimTemplate
metadata:
  name: new-admin-template
  namespace: apim
spec:
  apimTemplateRule:
    group: apim.googleapis.com
    kind: ApimTemplateRule
    name: template-rule
    namespace: apim
  templates:
  - policies:
      - group: apim.googleapis.com
        kind: SpikeArrest
        name: spike-arrest
        namespace: apim
      - group: apim.googleapis.com
        kind: Javascript
        name: js-add-headers
        namespace: apim
      - group: apim.googleapis.com
        kind: AssignMessage
        name: google-token-policy
        namespace: apim

Aplica la plantilla actualizada con el siguiente comando:
```
kubectl apply -f new-admin-template.yaml
```

Implementa la política de Apigee Gateway

En este paso, aplicarás un nuevo archivo a tu puerta de enlace que incluya las especificaciones de un ApigeeGatewayPolicy. Esta política se usa para implementar la plantilla de Apigee en la puerta de enlace.

Implementa la política de Apigee Gateway:

Crea un nuevo archivo yaml llamado apigee-gateway-policy-withSA.yaml en el espacio de nombres apim.

Copia el contenido del siguiente archivo en el archivo nuevo que creaste:

# apigee-gateway-policy-withSA.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: ApigeeGatewayPolicy
metadata:
  name: apim-template-injection
  namespace: apim
spec:
  serviceAccount: apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com
  ref:
    group: apim.googleapis.com
    kind: ApimTemplate
    name: new-admin-template
    namespace: apim
  targetRef:
    group: apim.googleapis.com
    kind: APIMExtensionPolicy
    name: global-ext-lb1-apim-policy
    namespace: apim

Aplica la política:

kubectl apply -f apigee-gateway-policy-withSA.yaml

Verifica el estado de implementación de la nueva política de puerta de enlace:
```
kubectl -n apim get ApigeeGatewayPolicy
```
Una vez implementada, la política STATUS debería mostrar CREATED.

Después de implementar la nueva política de la puerta de enlace, espera dos minutos antes de enviar una solicitud a la puerta de enlace para permitir que la política se propague al clúster.

Valida la aplicación de la política

Para confirmar que las políticas de Apigee Gateway funcionen como se espera, envía solicitudes a la puerta de enlace como se describe en las siguientes secciones.

Verifica la aplicación de la política AssignMessage

Para confirmar que el token de {company_name} se inserta en la solicitud con la política de AssignMessage, envía una solicitud a la puerta de enlace con el siguiente comando:

curl http://GATEWAY_IP_ADDRESS/get -H "Host: HOST_NAME" -H "x-api-key: API_KEY"

Aquí:

GATEWAY_IP_ADDRESS es la dirección IP de la puerta de enlace. Puedes recuperar la dirección IP de la puerta de enlace con el siguiente comando:
```
kubectl get gateway GATEWAY_NAME
```
HOST_NAME es el nombre del host.
API_KEY es el valor de la clave de API.

Una respuesta correcta debe incluir un encabezado Authorization con el token portador generado, similar al siguiente:

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

Confirma la aplicación de la política de SpikeArrest

Para probar la aplicación de la política de SpikeArrest, envía una solicitud a la puerta de enlace diez veces en un plazo de un minuto.

Puedes ejecutar la siguiente secuencia de comandos para generar las solicitudes:

#!/bin/sh
for i in $(seq 1 11); do
    curl http://GATEWAY_IP_ADDRESS/get -H "Host: HOST_NAME" -H "x-api-key: API_KEY"
    sleep 1
done

Aquí:

GATEWAY_IP_ADDRESS es la dirección IP de la puerta de enlace. Puedes recuperar la dirección IP de la puerta de enlace con el siguiente comando, en el que GATEWAY_NAME es el nombre de la puerta de enlace:
```
kubectl get gateways.gateway.networking.k8s.io GATEWAY_NAME -o=jsonpath="{.status.addresses[0].value}"
```
HOST_NAME es el nombre de host definido en el HTTPRoute de la puerta de enlace.
API_KEY es el valor de la clave de API que se obtuvo en Configuración de pruebas.

La respuesta aparecerá de la siguiente manera:

"fault":{"faultstring":"Spike arrest violation. Allowed rate : MessageRate{capacity=5, period=Minutes}","detail":{"errorcode":"policies.ratelimit.SpikeArrestViolation"}}}

Solucionar problemas

Si tienes problemas para agregar políticas a la puerta de enlace de GKE, consulta Soluciona problemas del operador de APIM para encontrar soluciones a errores habituales.

¿Qué sigue?

Obtén más información sobre la política SpikeArrest.
Obtén más información sobre la política de JavaScript.