Esta página foi traduzida pela API Cloud Translation.

Usar políticas de gerenciamento de API com o operador Apigee APIM para Kubernetes

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

Confira a documentação da Apigee Edge.

Esta página descreve como modificar o gateway do Google Kubernetes Engine (GKE) em execução no cluster para aplicar políticas de gerenciamento de API do Apigee usando o operador APIM do Apigee para Kubernetes (pré-lançamento).

Antes de começar

Antes de começar esta tarefa, siga estas etapas:

Confirme se o cluster do GKE tem uma Identidade da carga de trabalho configurada. Consulte Criar uma identidade da carga de trabalho para conferir as etapas necessárias.
Confirme se o cluster tem um gateway do GKE configurado e funcionando. Consulte Como implantar gateways para mais detalhes.
Instale o operador do APIM. Consulte Instalar o operador do Apigee APIM para Kubernetes para ver as instruções de instalação.

Funções exigidas

Se você tiver atribuído os papéis necessários à sua conta de serviço, conforme descrito em Instalar o operador APIM do Apigee para Kubernetes, não será necessário ter outras permissões ou papéis do IAM para concluir essas tarefas.

É possível autorizar ações em recursos no cluster do Google Kubernetes Engine usando o mecanismo integrado de controle de acesso baseado em papéis (RBAC, na sigla em inglês) no Kubernetes. Para mais informações, consulte Autorizar ações em clusters usando o controle de acesso baseado em papéis.

Visão geral

As seções a seguir descrevem as etapas necessárias para modificar o gateway do GKE para usar as políticas do Apigee com o operador do APIM. Neste tutorial, você vai:

Defina a política de extensão do APIM.
Defina o produto da API.
Defina o conjunto de operações da API.
Teste a extensão de serviço da Apigee.
Acesse a Análise da API Apigee no console do Google Cloud.

Definir a política de extensão do APIM

Nesta etapa, você vai definir a política de extensão do APIM e aplicá-la ao gateway do GKE em execução no cluster. Essa política governa todo o tráfego que passa pelo gateway e o HTTPRoutes associado, operando de maneira semelhante a um flowhook no nível do ambiente no Apigee.

Defina a política de extensão do APIM:

Crie um novo arquivo chamado global-ext-lb1-apim-policy.yaml no namespace apim.

Copie o conteúdo a seguir no novo arquivo:

# global-ext-lb1-apim-policy.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: APIMExtensionPolicy
metadata:
  name: global-ext-lb1-apim-policy 
  namespace: apim
spec:
  apigeeenv: ENV_NAME # optional
  location: global
  failOpen: false
  timeout: 1000ms
  targetRef: # identifies the Gateway where the extension should be applied
    name: global-ext-lb1 
    kind: Gateway
    namespace: default

Em que ENV_NAME é o nome do ambiente da Apigee criado na etapa de instalação Criar um ambiente da Apigee.

Observação:se você instalou o Operador de APIM usando a flag generateEnv=TRUE, o campo apigeeenv não é necessário.

Confira todos os ambientes disponíveis na página Ambientes da Apigee no console do Google Cloud:

Acessar "Ambientes"

Aplique a política:
```
kubectl -n apim apply -f global-ext-lb1-apim-policy.yaml
```
Depois que o yaml é aplicado, o operador do APIM cria recursos de rede em segundo plano.
Verifique o status da política de extensão de API usando o seguinte comando:
```
kubectl -n apim get APIMExtensionPolicy
```
A saída será semelhante a esta, com um State de RUNNING:
```
NAME                         STATE      ERRORMESSAGE
global-ext-lb1-apim-policy   RUNNING  
```
Observação:pode levar até cinco minutos para que a política seja propagada para todas as instâncias do balanceador de carga.
Use o comando a seguir para enviar uma solicitação ao gateway:
```
curl http://GATEWAY_IP_ADDRESS/get -H "Host: HOST_NAME"
```
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.
A solicitação vai falhar com uma resposta semelhante a esta:
```
{"fault":{"faultstring":"Raising fault. Fault name : RF-insufficient-request-raise-fault","detail":{"errorcode":"steps.raisefault.RaiseFault"}}}
```
Isso indica que a política de extensão do Apigee está ativa e que a aplicação de chaves de API e a verificação de token de acesso estão ativas.

Definir o produto da API

Defina o produto da API:

Crie um novo arquivo chamado api-product.yaml no namespace apim.

Copie o conteúdo a seguir no novo arquivo:

# api-product.yaml
  apiVersion: apim.googleapis.com/v1alpha1
  kind: APIProduct
  metadata:
    name: api-product
    namespace: apim
  spec:
    approvalType: auto
    description: Http bin GET calls
    displayName: api-product
    enforcementRefs:
      - name: global-ext-lb1-apim-policy
        kind: APIMExtensionPolicy
        group: apim.googleapis.com
        namespace: apim
    attributes:
      - name: access
        value: private

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

Definir o conjunto de operações da API

Defina o conjunto de operações da API para o produto criado na etapa anterior:

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

Copie o conteúdo a seguir para o novo arquivo. Esse arquivo define uma política de cota e as operações REST disponíveis para o produto da API definido na etapa anterior:

# apim-policies.yaml
  apiVersion: apim.googleapis.com/v1alpha1
  kind: APIOperationSet
  metadata:
    name: item-set
  spec:
    apiProductRefs:
      - name: api-product
        kind: APIProduct
        group: apim.googleapis.com
        namespace: apim
    quota:
      limit: 10
      interval: 1
      timeUnit: minute
    restOperations:
      - name: GetItems
        path: /get
        methods:
          - GET

Aplique o arquivo ao gateway:

kubectl -n apim apply -f apim-policies.yaml

Testar a extensão de serviço da Apigee

Nesta etapa, você vai usar a interface da Apigee no console do Google Cloud para testar a extensão de serviço da Apigee e a política de extensão da Apigee aplicada ao gateway.

Como configurar o teste

Configure os recursos de API necessários para os testes:

Acesse a página Gerenciamento de APIs da Apigee no console do Google Cloud:
Gerenciamento de APIs da Apigee
Selecione a organização da Apigee em que você instalou o operador da APIM.
Crie um desenvolvedor:
1. Selecione Distribuição > Desenvolvedores.
2. Na página Desenvolvedores, clique em + Criar.
3. Na página Adicionar desenvolvedor, preencha os campos obrigatórios com os valores que quiser.
4. Clique em Adicionar.
Crie um app:
1. Selecione Distribuição> Apps.
2. Na página Apps, clique em + Criar.
3. Na página Criar app, preencha os campos obrigatórios na seção Detalhes do app usando os seguintes valores:
  - Nome do app: demo-app
  - Desenvolvedor: selecione o desenvolvedor que você criou na etapa anterior ou outro desenvolvedor na lista.
4. Na seção Credenciais do app, clique em + Adicionar credencial.
5. Na seção Credencial, preencha os campos obrigatórios na seção Detalhes da credencial com os seguintes valores:
  - Nome da credencial: demo-credential
  - Tipo de credencial: selecione Chave de API.
6. Clique em Criar.
7. Na seção Produtos, clique em + Adicionar produtos.
8. Selecione o api-product-1 criado na etapa anterior.
9. Clique em Adicionar.
10. Clique em Criar.
Na página App Details, na seção Credential, clique em para mostrar o valor da Key.
Copie o valor Key. Você vai usar essa chave para fazer chamadas de API para seu serviço em uma etapa posterior.
Na página Detalhes do app, na seção Credencial, clique em para mostrar o valor do App Secret.
Copie o valor do Secreto do app. Você vai usar esse valor para gerar um token de acesso em uma etapa posterior.

Testar a aplicação de chaves de API

Use o comando a seguir para enviar uma solicitação ao gateway usando a chave de API obtida em uma etapa anterior:

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 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 solicitação precisa ser bem-sucedida e retornar uma resposta semelhante a esta:

{
  "args": {}, 
  "headers": {
    "Accept": "*/*", 
    "Host": "apigee-apim-operator-test.apigee.net", 
    "User-Agent": "curl/8.7.1", 
    "X-Api-Key": "f0N6sXXXclGXXXe0oP5XXXdA20PjgrP2x8xXXh7z4XXXKiYt", 
    "X-Cloud-Trace-Context": "bb3a768787099bda628781188bfb318b/15554891713516675739"
  }, 
  "origin": "34.54.193.72", 
  "url": "https://34.54.193.72/get"
}

Testar a aplicação de cota

Para testar a aplicação de cota definida na política de extensão do APIM, envie a solicitação da etapa anterior ao gateway dez vezes no período de 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.

Essa ação deve acionar uma violação de cota e gerar uma falha semelhante a esta:

{"fault":{"faultstring":"Rate limit quota violation. Quota limit  exceeded. Identifier : _default","detail":{"errorcode":"policies.ratelimit.QuotaViolation"}}}

Testar a aplicação de operações de descanso

Para testar a aplicação de operações de descanso, use o comando a seguir para enviar uma solicitação ao gateway usando um URL que não está no conjunto de operações da API:

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

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 solicitação vai falhar com uma resposta semelhante a esta:

{"fault":{"faultstring":"Invalid ApiKey for given resource","detail":{"errorcode":"oauth.v2.InvalidApiKeyForGivenResource"}}}

Conferir a análise de APIs da Apigee no console do Google Cloud

É possível conferir o tráfego de API processado pelo gateway do GKE e a APIMExtensionPolicy instalada usando a Análise de API do Apigee no console do Google Cloud:

Acesse a página Gerenciamento da API Apigee no console do Google Cloud:
Gerenciamento de APIs da Apigee
Selecione a organização da Apigee em que você instalou o operador da APIM.
Selecione Analytics > Métricas da API no menu de navegação lateral.
Na guia API Proxy Performance, escolha o ambiente que você criou na etapa de instalação opcional Criar um ambiente da Apigee ou o ambiente criado pelo operador do APIM durante a instalação. O nome do ambiente vai começar com o prefixo apigee-ext-proc-enabled-env.
Observe o tráfego da API registrado.

Resolver problemas

Se você tiver problemas ao usar políticas de gerenciamento de API com o Operador de APIM, consulte Solução de problemas do Operador de APIM para soluções de erros comuns.

A seguir

Saiba como adicionar políticas ao gateway do GKE.
Saiba como desinstalar o operador Apigee APIM para Kubernetes.