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.

Esta página descreve como adicionar políticas de execução do Apigee e uma política de injeção de Google token ao gateway do Google Kubernetes Engine (GKE) com o operador APIM do Apigee para Kubernetes (pré-lançamento). Adicionar um conjunto de políticas disponíveis ao gateway permite estender a funcionalidade do gateway além da aplicação de produtos de API para incluir mais regras de negócios e segurança.

O operador 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.
Atualize o modelo da Apigee para incluir a regra do modelo .

Implante a política do Apigee Gateway 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 usado como exemplo neste guia, você precisa ter uma conta de serviço com as funções necessárias para criar tokens na Apigee e implantar proxies e extensões. Se você não quiser criar tokens Google , não será necessário adicionar as funções adicionais à sua conta de serviço e você poderá 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 com o nome apigee-apim-gsa no guia de instalação do operador da APIM do Apigee para Kubernetes, pule esta etapa e prossiga 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 gateway do GKE com uma ou mais políticas para estender a funcionalidade dele. Este exemplo de tutorial 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 arquivo yaml a seguir desempenha uma função diferente ao avaliar as solicitações enviadas ao gateway:

A política SpikeArrest controla a taxa de mensagens de pico 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 reduzir picos repentinos no tráfego, consulte a política SpikeArrest.
A política de JavaScript permite adicionar um código JavaScript personalizado às solicitações do gateway. Neste exemplo, a política é usada para adicionar um cabeçalho personalizado à solicitação. Para saber mais sobre como a política de JavaScript é usada para adicionar código personalizado, consulte Política de JavaScript.
A política de injeção de token Google é usada para injetar um token de acesso de Google autenticação nas solicitações do gateway usando a política AssignMessage. A Apigee é compatível com o uso de Google tokens do OAuth ou do OpenID Connect para autenticação com serviços 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 para o novo arquivo que você criou:

# 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

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

Criar uma regra de modelo 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 pelos 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 pelos desenvolvedores de serviços.

Criar uma regra de modelo

Crie uma regra de modelo para aplicar a política AssignMessage:

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

Aplicar a regra de modelo

Aplique a regra de modelo usando o seguinte comando:

kubectl apply -f template-rule.yaml

Atualizar o modelo da Apigee para incluir as regras do modelo

Atualize o modelo do Apigee para incluir a regra de modelo que você criou na seção anterior:

Crie um novo arquivo yaml com o nome new-admin-template.yaml no namespace apim.

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

# 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

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

Implantar 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 da Apigee no gateway.

Implante a política do gateway da Apigee:

Crie um novo arquivo yaml com o nome apigee-gateway-policy-withSA.yaml no namespace apim.

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

# 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

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.

Após a implantação da nova política do gateway, aguarde dois minutos antes de enviar uma solicitação para o 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 para o gateway, conforme descrito nas seções a seguir.

Verificar a aplicação da política AssignMessage

Para confirmar que o token {company_name} é 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 portador 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"
}

Confirmar a aplicação da política SpikeArrest

Para testar a aplicação da política SpikeArrest, envie uma solicitação para o 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 extrair 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 na Configuração de teste.

A resposta será semelhante a esta:

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

Resolver problemas

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

A seguir

Saiba mais sobre a política Spike Arrest.
Saiba mais sobre a política de JavaScript.