Esta página foi traduzida pela API Cloud Translation.

Adicionar políticas ao gateway do GKE

Esta página se aplica à Apigee, mas não à Apigee híbrida.

Confira a documentação da Apigee Edge.

Nesta página, descrevemos como adicionar políticas de tempo de execução do Apigee e uma política de injeção de token Google ao gateway do Google Kubernetes Engine (GKE) com o operador de APIM do Apigee para Kubernetes. Ao adicionar um conjunto disponível de políticas ao Gateway, é possível estender a funcionalidade dele além da aplicação do produto de API para incluir mais regras de segurança e de negócios.

O operador do Apigee APIM para Kubernetes pode ser usado para adicionar as seguintes políticas ao gateway:

Visão geral

As seções a seguir descrevem como:

Adicione políticas ao GKE Gateway.
Crie uma regra de modelo para aplicar o uso das políticas.
Crie um modelo da Apigee para usar a regra de modelo .

Implante a política do gateway do Apigee com o modelo.
Validar a aplicação da política.

Antes de começar

Para modificar o gateway do GKE com o conjunto completo de políticas usadas como exemplo neste guia, você precisa ter uma conta de serviço com as funções necessárias para criar tokens no Apigee e implantar proxies e extensões. Se você escolher não criar tokens Google , não será necessário adicionar os papéis extras à conta de serviço. Você pode pular para a próxima seção.

Para criar uma conta de serviço com as permissões necessárias, faça o seguinte:

Se você criou uma conta de serviço chamada apigee-apim-gsa no guia de instalação do operador de APIM da Apigee para Kubernetes, pule esta etapa e siga para a próxima. Caso contrário, crie a conta de serviço:
```
gcloud iam service-accounts create apigee-apim-gsa --project=$PROJECT_ID
```

Conceda à conta de serviço o papel necessário para criar tokens:

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

Conceda à conta de serviço apigee-apim-gsa o papel necessário para implantar proxies e extensões:

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

Modificar o gateway do GKE com políticas

Você pode modificar o GKE Gateway com uma ou mais políticas para estender a funcionalidade dele. Este exemplo aplica um arquivo yaml ao gateway, que inclui as especificações de duas políticas do Apigee e uma política de injeção de token Google .

Cada uma das políticas aplicadas ao gateway usando o seguinte arquivo yaml desempenha uma função diferente ao avaliar solicitações enviadas ao gateway:

A política SpikeArrest controla a taxa máxima de mensagens definindo uma taxa máxima de solicitações permitidas em uma unidade de tempo. Neste exemplo, a taxa máxima é definida como cinco por minuto. Para saber mais sobre como a política SpikeArrest é usada para suavizar picos repentinos no tráfego, consulte Política SpikeArrest.
A política de JavaScript permite adicionar código JavaScript personalizado às solicitações do gateway. Neste exemplo, a política é usada para adicionar um cabeçalho personalizado à solicitação. Para mais informações sobre como a política JavaScript é usada para adicionar código personalizado, consulte Política JavaScript.
A política de injeção de token Google é usada para injetar um token de acesso de autenticação Google nas solicitações do gateway usando a política AssignMessage. A Apigee é compatível com o uso de tokens do OAuth ou do OpenID Connect para autenticação com serviços do Google . Google Para saber mais sobre tokens de autenticação, consulte Como usar a autenticação do Google.

Adicione as políticas ao gateway:

Crie um novo arquivo chamado apigee-policies.yaml no namespace apim.

Copie o conteúdo do arquivo a seguir no novo arquivo que você criou:

# apigee-policies.yaml
apiVersion: apim.googleapis.com/v1
kind: SpikeArrest
metadata:
  name: spike-arrest
  namespace: apim
spec:
  identifier:
    ref: request.header.name
  useEffectiveCount: true
  peakMessageRate:
    value: "5pm"
---
apiVersion: apim.googleapis.com/v1
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/v1
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
---
apiVersion: apim.googleapis.com/v1
kind: KVM
metadata:
  name: kvm-1
  namespace: apim
spec:
  delete:
  - keys:
    - value: mykey
  exclusiveCache: true
  expiryTimeInSecs: 3600
  get:
  - assignTo: response.header.mykvm
    keys:
    - value: mykey
  initialEntries:
  - keys:
    - key1
    values:
    - val1
  - keys:
    - mykey
    values:
    - initvalue
  isEncrypted: false
  put:
  - keys:
    - value: mykey
    values:
    - value: request.header.mykvm
  scope: environment
---
apiVersion: apim.googleapis.com/v1
kind: OASValidation
metadata:
  name: oas-validation-1
  namespace: apim
spec:
  openApiSpec: |
    openapi: 3.0.4
    info:
      title: Sample API
      description: Optional multi/single line description.
      version: 0.1.9
    servers:
      - url: http://apigee-apim-operator-test.apigee.net
        description: Optional server description, our main host in httproute
    paths:
      /get:
        get:
          summary: just for test
          description: Optional extended description in CommonMark or HTML.
          parameters:
            - name: X-Request-Type
              in: header
              description: Must be 'internal' or 'external'.
              required: true
              schema:
                type: string
                enum:
                  - internal
                  - external
          responses:
            '200': # status code
              description: A JSON object
              content:
                application/json:
                  schema:
                    type: object
                    properties:
                      headers:
                        type: object
  source: request
---
apiVersion: apim.googleapis.com/v1
kind: ServiceCallout
metadata:
  name: service-callout-1
  namespace: apim
spec:
  request:
    clearPayload: true
    variable: myRequest
    ignoreUnresolvedVariables: true
    removeActions:
      - payload: true
      - queryParams:
        - name: rq-param1
        - name: rq-param2
    copyActions:
      - version: true
      - verb: true
    addActions:
      - headers:
        - name: X-header1
          value: value1
        - name: X-header2
          value: value2
      - queryParams:
        - name: q-param1
          value: value1
        - name: q-param2
          value: value2
    setActions:
      - verb: PUT
      - formParams:
        - name: f-param1
          value: value1
        - name: f-param2
          value: value2
  response: calloutResponse
  timeout: 30000
  httpTargetConnection:
    URL: https://httpbin.org/put
    properties:
      - name: success.codes
        value: 1xx,2xx,3xx,400
      - name: supports.http11
        value: "true"

Aplique o arquivo yaml ao gateway usando o seguinte comando:
```
kubectl -n apim apply -f apigee-policies.yaml
```

Criar uma TemplateRule como um modelo SharedFlow

Nesta etapa, você vai criar um TemplateRule para aplicar as políticas adicionadas ao gateway. Uma regra de modelo é uma regra para SharedFlows criada por administradores da organização para garantir que apenas políticas aprovadas sejam aplicadas ao tráfego do gateway por desenvolvedores de serviços. Uma regra de modelo garante que os desenvolvedores entendam quais políticas estão disponíveis para eles, quais são necessárias para casos de uso específicos e quais não podem ser usadas por desenvolvedores de serviços.

Criar uma regra de modelo

Crie uma regra de modelo para aplicar o uso da política AssignMessage:

Crie um arquivo yaml chamado template-rule.yaml no namespace apim.
Copie o conteúdo do arquivo a seguir no novo arquivo que você criou:
```
# template-rule.yaml
apiVersion: apim.googleapis.com/v1
kind: ApimTemplateRule
metadata:
  name: template-rule
  namespace: apim
spec:
  allowList: [SpikeArrest, Javascript, GenerateJWT, KVM, OASValidation, OAuthv2, ServiceCallout]
  requiredList: [AssignMessage]
  denyList: []
```
Neste exemplo, a regra de modelo informa aos desenvolvedores que a política AssignMessage que descreve a política de injeção de token Google é obrigatória. Ele também informa aos desenvolvedores que eles podem usar as políticas SpikeArrest, JavaScript, GenerateJWT, KVM, OASValidation, OAuthv2 e ServiceCallout no gerenciamento de APIs. Não há políticas especificadas na lista de bloqueio.

Aplicar a regra de modelo

Aplique a regra de modelo usando o seguinte comando:

kubectl apply -f template-rule.yaml

Criar um modelo do Apigee para usar a regra de modelo

Crie um modelo do Apigee para incluir a regra de modelo criada na seção anterior:

Crie um arquivo yaml chamado new-admin-template.yaml no namespace apim.

Copie o conteúdo do arquivo a seguir no novo arquivo que você criou:

# new-admin-template.yaml
apiVersion: apim.googleapis.com/v1
kind: ApimTemplate
metadata:
  name: new-admin-template
  namespace: apim
spec:
  apimTemplateRule:
    group: apim.googleapis.com
    kind: ApimTemplateRule
    name: template-rule
    namespace: apim
  templates:
  - mode: REQUEST
    flows:
    - name: preflow
      policies:
      - group: apim.googleapis.com
        kind: OASValidation
        name: oas-validation-1
        namespace: apim
      - group: apim.googleapis.com
        kind: SpikeArrest
        name: spike-arrest
        namespace: apim
    - name: ConditionalGetFlow
      policies:
      - group: apim.googleapis.com
        kind: Javascript
        name: js-add-headers
        namespace: apim
      condition: request.verb="GET"
    - name: postflow
      policies:
      - group: apim.googleapis.com
        kind: AssignMessage
        name: google-token-policy
        namespace: apim
      - group: apim.googleapis.com
        kind: ServiceCallout
        name: service-callout-1
        namespace: apim
  - mode: RESPONSE
    flows:
    - name: postflow
      policies:
      - group: apim.googleapis.com
        kind: KVM
        name: kvm-1
        namespace: apim

Aplique o novo modelo usando o seguinte comando:
```
kubectl apply -f new-admin-template.yaml
```

Implante a política do gateway da Apigee

Nesta etapa, você vai aplicar um novo arquivo ao gateway que inclui as especificações de um ApigeeGatewayPolicy. Essa política é usada para implantar o modelo do Apigee no gateway.

Implante a política do gateway da Apigee:

Crie um arquivo yaml chamado apigee-gateway-policy-withSA.yaml no namespace apim.

Copie o conteúdo do arquivo a seguir no novo arquivo que você criou:

# apigee-gateway-policy-withSA.yaml
apiVersion: apim.googleapis.com/v1
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

Aplique a política:

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

Verifique o status da implantação da nova política de gateway:
```
kubectl -n apim get ApigeeGatewayPolicy
```
Depois de implantada, a política STATUS vai mostrar CREATED.

Depois que a nova política de gateway for implantada, aguarde dois minutos antes de enviar uma solicitação ao gateway para permitir que a política seja propagada para o cluster.

Validar a aplicação da política

Para confirmar se as políticas do Apigee Gateway estão funcionando conforme o esperado, envie solicitações ao gateway conforme descrito nas seções a seguir.

Aplicação da política AssignMessage

Para confirmar que o token {company_name} foi injetado na solicitação usando a política AssignMessage, envie uma solicitação ao gateway usando o seguinte comando:

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

Em que:

GATEWAY_IP_ADDRESS é o endereço IP do gateway. É possível recuperar o endereço IP do gateway usando o seguinte comando:
```
kubectl get gateway GATEWAY_NAME
```
HOST_NAME é o nome do host.
API_KEY é o valor da chave de API.

Uma resposta bem-sucedida precisa incluir um cabeçalho Authorization com o token de autenticação gerado, semelhante a este:

{
  "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"
}

Aplicação da política SpikeArrest

É possível testar a aplicação da política SpikeArrest enviando uma solicitação ao gateway dez vezes em um minuto.

Você pode executar o script a seguir para gerar as solicitações:

#!/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

Em que:

GATEWAY_IP_ADDRESS é o endereço IP do gateway. É possível recuperar o endereço IP do gateway usando o seguinte comando, em que GATEWAY_NAME é o nome do gateway:
```
kubectl get gateways.gateway.networking.k8s.io GATEWAY_NAME -o=jsonpath="{.status.addresses[0].value}"
```
HOST_NAME é o nome do host definido no HTTPRoute do gateway.
API_KEY é o valor da chave de API obtido em Configuração de teste.

A resposta vai aparecer assim:

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

Aplicação da política de JavaScript

Para confirmar que a política do JavaScript está funcionando conforme o esperado, envie uma solicitação ao gateway usando o seguinte comando:

curl http://GATEWAY_IP_ADDRESS/get \
  -H "Host: HOST_NAME" \
  -H "x-api-key: API_KEY" \
  -H "X-Request-Type: external" -i

Em que:

GATEWAY_IP_ADDRESS é o endereço IP do gateway. É possível recuperar o endereço IP do gateway usando o seguinte comando, em que GATEWAY_NAME é o nome do gateway:
```
kubectl get gateways.gateway.networking.k8s.io GATEWAY_NAME -o=jsonpath="{.status.addresses[0].value}"
```
HOST_NAME é o nome do host definido no HTTPRoute do gateway.
API_KEY é o valor da chave de API obtido em Configuração de teste.

A política JavaScript define três cabeçalhos de solicitação: First, Second e Sum, conforme mostrado na resposta:

HTTP/1.1 200 OK
...
{
  "args": {},
  "headers": {
    ...
    "First": "1.0",
    ...
    "Second": "1.0",
    "Sum": "2",
    ...
  },
  ...
}

Aplicação da política OASValidation

Para confirmar que a política OASValidation está funcionando conforme o esperado, envie uma solicitação ao gateway usando o seguinte comando:

curl "http://GATEWAY_IP_ADDRESS/get"  \
  -H "Host: HOST_NAME" \
  -H "x-api-key: API_KEY" \
  -H "X-Request-Type: badvalue"

Em que:

GATEWAY_IP_ADDRESS é o endereço IP do gateway. É possível recuperar o endereço IP do gateway usando o seguinte comando, em que GATEWAY_NAME é o nome do gateway:
```
kubectl get gateways.gateway.networking.k8s.io GATEWAY_NAME -o=jsonpath="{.status.addresses[0].value}"
```
HOST_NAME é o nome do host definido no HTTPRoute do gateway.
API_KEY é o valor da chave de API obtido em Configuração de teste.

O comando inclui um valor inválido para o cabeçalho X-Request-Type. A solicitação vai falhar com uma resposta semelhante a esta:

{"fault":{"faultstring":"OASValidation oas-validation-1 with resource \"oas:\/\/oas-validation-1.yaml\": failed with reason: \"[ERROR - Instance value (\"badvalue\") not found in enum (possible values: [\"internal\",\"external\"]): []]\"","detail":{"errorcode":"steps.oasvalidation.Failed"}}}

Enviar a mesma solicitação com um valor válido para o cabeçalho X-Request-Type vai funcionar. Exemplo:

curl "http://GATEWAY_IP_ADDRESS/get"  \
  -H "Host: HOST_NAME" \
  -H "x-api-key: API_KEY" \
  -H "X-Request-Type: external" -i

Em que:

GATEWAY_IP_ADDRESS é o endereço IP do gateway. É possível recuperar o endereço IP do gateway usando o seguinte comando, em que GATEWAY_NAME é o nome do gateway:
```
kubectl get gateways.gateway.networking.k8s.io GATEWAY_NAME -o=jsonpath="{.status.addresses[0].value}"
```
HOST_NAME é o nome do host definido no HTTPRoute do gateway.
API_KEY é o valor da chave de API obtido em Configuração de teste.

Aplicação da política ServiceCallout

Para verificar a aplicação da política ServiceCallout, abra uma sessão de depuração e envie algumas solicitações válidas ao proxy.

Para abrir uma sessão de depuração, siga estas etapas:

No console Google Cloud , acesse a página Proxies de API.
Acessar proxies de API
Selecione o proxy global-ext-lb1-apim-policy implantado no ambiente criado para o operador de APIM do Apigee para Kubernetes.
Clique na guia Depurar.
Na janela Sessão de depuração, clique em Iniciar sessão de depuração.
No painel Sessão de depuração, faça as seguintes seleções:
- Ambiente: selecione o ambiente criado para o operador do APIM na lista de ambientes disponíveis.
- Filtro: selecione Nenhum (todas as transações).
Clique em Iniciar.

Depois que a sessão for iniciada, você poderá enviar solicitações válidas ao proxy:

curl "GATEWAY_IP_ADDRESSget"  \
  -H "Host: HOST_NAME" \
  -H "x-api-key: API_KEY" \
  -H "X-Request-Type: external" -i

Em que:

GATEWAY_IP_ADDRESS é o endereço IP do gateway. É possível recuperar o endereço IP do gateway usando o seguinte comando, em que GATEWAY_NAME é o nome do gateway:
```
kubectl get gateway GATEWAY_NAME
```
HOST_NAME é o nome do host definido no HTTPRoute do gateway.
API_KEY é o valor da chave de API obtido em Configuração de teste.

As transações de solicitação e resposta são exibidas no painel Transações. Selecione uma transação concluída na lista para mostrar o fluxo. Você vai ver que a política ServiceCallout foi executada com sucesso.

Aplicação da política da KVM

Quando a política de KVM é executada com sucesso, ela inicializa o KVM com um valor inicial para a chave mykey. Quando há uma transação de resposta, a política de KVM recupera o valor de mykey e o armazena no cabeçalho de resposta mykvm. Quando a política de KVM é executada novamente, ela insere o novo valor de mykey obtido do cabeçalho da solicitação mykvm.

É possível verificar os cabeçalhos de cada transação para confirmar se a política está armazenando um valor no KVM em uma transação e recuperando o mesmo valor na próxima transação, conforme mostrado no exemplo a seguir.

Observação: use curl com a opção de linha de comando -i para conferir os cabeçalhos de resposta.

Teste a política do KVM:

Envie uma solicitação para o gateway:
```
curl -i "http://GATEWAY_IP_ADDRESS/get" \
  -H "Host: HOST_NAME" \
  -H "x-api-key: API_KEY" \
  -H "X-Request-Type: external" \
  -H "KVM_NAME: next-value1" -i
```
Em que:
- GATEWAY_IP_ADDRESS é o endereço IP do gateway. É possível recuperar o endereço IP do gateway usando o seguinte comando, em que GATEWAY_NAME é o nome do gateway:
```
kubectl get gateway GATEWAY_NAME
```
- HOST_NAME é o nome do host definido no HTTPRoute do gateway.
- API_KEY é o valor da chave de API obtido em Configuração de teste.
- KVM_NAME é o nome do KVM.

Verifique os cabeçalhos de resposta para confirmar se a política do KVM foi executada e se um valor inicial foi armazenado para mykvm. A resposta será semelhante a esta:

HTTP/1.1 200 OK
access-control-allow-credentials: true
access-control-allow-origin: *
Content-Length: 517
content-type: application/json
date: ...
server: gunicorn/19.9.0
mykvm: initvalue
via: 1.1 google
{
  "args": {
  ...
  "url": "http://apigee-apim-operator-test.apigee.net/get"
  }
}

Envie outra solicitação ao gateway:

curl -i "http://GATEWAY_IP_ADDRESS/get" \
  -H "Host: HOST_NAME" \
  -H "x-api-key: API_KEY" \
  -H "mykvm: next"X-Request-Type: external" -H "mykvm: next-value2" -i

A resposta será semelhante a esta:

HTTP/1.1 200 OK
access-control-allow-credentials: true
access-control-allow-origin: *
Content-Length: 517
content-type: application/json
date: ...
server: gunicorn/19.9.0
mykvm: next-value2
via: 1.1 google
{
  "args": {
  ...
  "url": "http://apigee-apim-operator-test.apigee.net/get?rq-param2=rq-val1&x-param1=xval1"
  }
}

É possível ver que a política de KVM foi executada com sucesso porque o valor do cabeçalho mykvm foi atualizado para o valor do cabeçalho de solicitação mykvm.

Envie mais uma solicitação:

curl -i "http://GATEWAY_IP_ADDRESS/get" \
  -H "Host: HOST_NAME" \
  -H "x-api-key: API_KEY" \
  -H "X-Request-Type: external" -H "mykvm: next-value3" -i

A resposta será semelhante a esta:

HTTP/1.1 200 OK
access-control-allow-credentials: true
access-control-allow-origin: *
Content-Length: 517
content-type: application/json
date: ...
server: gunicorn/19.9.0
mykvm: next-value2
via: 1.1 google
{
  "args": {
  ...
  "url": "http://apigee-apim-operator-test.apigee.net/get?rq-param2=rq-val1&x-param1=xval1"
  }
}

O valor do cabeçalho mykvm é atualizado novamente, mostrando que o valor exibido na resposta é o armazenado na transação anterior.

Resolver problemas

Se você tiver problemas ao adicionar políticas ao GKE Gateway, consulte Resolver problemas do operador do APIM para encontrar soluções para erros comuns.

A seguir

Saiba mais sobre a política de detenção de pico.
Saiba mais sobre a política de JavaScript.

Adicionar políticas ao gateway do GKE Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Visão geral

Antes de começar

Modificar o gateway do GKE com políticas

Criar uma TemplateRule como um modelo SharedFlow

Criar uma regra de modelo

Aplicar a regra de modelo

Criar um modelo do Apigee para usar a regra de modelo

Implante a política do gateway da Apigee

Validar a aplicação da política

Aplicação da política AssignMessage

Aplicação da política SpikeArrest

Aplicação da política de JavaScript

Aplicação da política OASValidation

Aplicação da política ServiceCallout

Aplicação da política da KVM

Resolver problemas

A seguir

Adicionar políticas ao gateway do GKE