Criar uma APIMExtensionPolicy

Esta página se aplica à Apigee e à Apigee híbrida.

Confira a documentação da Apigee Edge.

Nesta página, descrevemos como aplicar políticas da Apigee ao tráfego que passa por um gateway do Kubernetes criando um recurso personalizado APIMExtensionPolicy. O operador da Apigee para Kubernetes monitora recursos APIMExtensionPolicy e configura o gateway de acordo.

Apigee

Siga estas etapas se você estiver usando o Apigee.

Antes de começar

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

• Confirme se o cluster do GKE tem a Identidade da carga de trabalho configurada. Consulte Configurar a Federação de Identidade da Carga de Trabalho para GKE 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 da Apigee para Kubernetes. Consulte Instalar o operador do Apigee para Kubernetes para instruções de instalação.

Criar o APIMExtensionPolicy

Nesta etapa, crie o APIMExtensionPolicy e aplique-o ao gateway do GKE em execução no cluster. Essa política rege todo o tráfego que passa pelo gateway e pelo HTTPRoutes associado, operando de maneira semelhante a um flowhook no nível do ambiente na Apigee hoje.

Observação:quando o APIMExtensionPolicy é aplicado a um gateway, o operador do Apigee para Kubernetes cria a extensão de tráfego necessária. Essa extensão de tráfego não é compatível com outras que possam estar presentes no gateway. Se você tiver várias extensões de tráfego ou preferir gerenciar a ordem delas por conta própria, use o ApigeeBackendService. Usar o ApigeeBackendService permite integrar o Apigee a um recurso GCPTrafficExtension com outras extensões. Consulte Criar um ApigeeBackendService para mais informações.

Para criar a APIMExtensionPolicy:

1. Crie um arquivo chamado global-ext-lb1-apim-policy.yaml com o conteúdo a seguir:

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

2. Substitua ENV_NAME pelo nome do ambiente da Apigee criado na etapa de instalação Criar um ambiente da Apigee.

   Observação:se você instalar o operador do Apigee para Kubernetes usando a flag generateEnv=TRUE, o campo apigeeEnv não será necessário.

   É possível conferir todos os ambientes disponíveis na página "Ambientes" do console Google Cloud .

3. Aplique a política:

   kubectl -n apim apply -f global-ext-lb1-apim-policy.yaml
       

   Depois que a política é aplicada, o operador do Apigee para Kubernetes cria recursos de rede em segundo plano.

4. Verifique o status do APIMExtensionPolicy usando o seguinte comando:

   kubectl -n apim get APIMExtensionPolicy
       

   A saída será parecida com 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.

Testar a política

Use o comando a seguir para enviar uma solicitação ao gateway:

1. Consiga o endereço IP do gateway:

   export GATEWAY_IP=$(kubectl get gateways.gateway.networking.k8s.io GATEWAY_NAME -n default -o=jsonpath='{.status.addresses[0].value}')
         

   echo $GATEWAY_IP
         

   Substitua GATEWAY_NAME pelo nome do gateway, por exemplo, global-ext-lb1.

2. Envie uma solicitação para um endpoint configurado no seu HTTPRoute:

   curl http://$GATEWAY_IP/get -H "Host: HOST_NAME"
         

   Substitua HOST_NAME pelo nome do host definido no HTTPRoute do gateway, por exemplo, example.httpbin.com.

3. A solicitação vai falhar porque defaultSecurityEnabled: true foi definido no recurso APIMExtensionPolicy, que ativa a verificação de chave de API e token de acesso. Uma resposta semelhante a esta vai aparecer:

   {"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 da Apigee está ativa e que a aplicação da chave de API e a verificação do token de acesso estão ativas.

A seguir

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

Apigee híbrido

Siga estas etapas se você estiver usando a Apigee híbrida.

Pré-lançamento — Apigee Operator for Kubernetes for Apigee hybrid

Este recurso está sujeito aos "Termos da Oferta Pré-GA" na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os recursos pré-GA estão disponíveis no estado em que se encontram e podem ter assistência limitada. Para mais informações, consulte as descrições das fases de lançamento.

Antes de começar

Este procedimento pressupõe que você tenha instalado o operador da Apigee para Kubernetes seguindo as etapas em Instalar o operador da Apigee para Kubernetes na Apigee híbrida.

Criar um secret de certificado TLS

O APIMExtensionPolicy exige o certificado público codificado em base64 associado ao nome do host do grupo de ambiente. Você criou esse certificado em Instalar o ambiente híbrido da Apigee usando o Helm. Forneça esse certificado ao operador criando um secret do Kubernetes no namespace apim.

1. Extraia a string de certificado codificada em base64 do arquivo criado durante a instalação:

   cat $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_ENV_GROUP.pem.base64
       

2. Crie um arquivo chamado secret-cert.yaml com o conteúdo a seguir:

   # secret-cert.yaml
   apiVersion: v1
   kind: Secret
   metadata:
     name: apigee-conf
     namespace: apim
   data:
     ca.crt: BASE64_ENCODED_CERT_STRING
       

3. Substitua BASE64_ENCODED_CERT_STRING pela saída do comando cat na etapa 1.
4. Aplique o secret ao cluster:

   kubectl apply -f secret-cert.yaml
       

Definir e aplicar o APIMExtensionPolicy

Defina um recurso APIMExtensionPolicy e aplique-o ao gateway do Istio em execução no cluster. Essa extensão de política intercepta o tráfego gerenciado pelo gateway e o HTTPRoutes associado a ele e aplica políticas da Apigee antes de encaminhar solicitações para o destino de back-end.

1. Crie um arquivo chamado istio-gateway-apim-policy.yaml com o conteúdo a seguir:

   # istio-gateway-apim-policy.yaml
   apiVersion: apim.googleapis.com/v1
   kind: APIMExtensionPolicy
   metadata:
     name: istio-gateway-apim-policy
     namespace: apim
   spec:
     apigeeEnv: ENV_NAME
     ingressCertSecret: apigee-conf
     apigeeAuthority: HOST_NAME
     apigeeIngressIP: INGRESS_IP_ADDRESS
     location: global
     failOpen: false
     timeout: 1000ms
     defaultSecurityEnabled: true
     targetRef: # identifies the Gateway where the extension should be applied
       group: gateway.networking.k8s.io
       kind: Gateway
       name: istio-gateway
       namespace: default
       

2. Substitua as seguintes variáveis:
   • ENV_NAME: o nome do ambiente híbrido da Apigee que você criou com as extensões de serviço ativadas, por exemplo, my-hybrid-env.
   • HOST_NAME: o nome de domínio usado para o grupo de ambiente, por exemplo, my-proxies.example.com.
   • INGRESS_IP_ADDRESS: o endereço IP de entrada para a entrada do tempo de execução híbrido da Apigee. Consulte Expor entrada da Apigee para detalhes sobre como recuperar esse IP.
3. Aplique a política ao cluster:

   kubectl -n apim apply -f istio-gateway-apim-policy.yaml
       

4. Depois que o recurso é aplicado, o operador do Apigee para Kubernetes começa a configurar os recursos de rede do gateway. Verifique o status de APIMExtensionPolicy.

   kubectl -n apim get APIMExtensionPolicy
       

5. Aguarde até que o STATE mostre RUNNING. A saída será parecida com esta:

   NAME                         STATE      ERRORMESSAGE
   istio-gateway-apim-policy    RUNNING
       

Testar a política

No APIMExtensionPolicy criado na etapa anterior, defaultSecurityEnabled foi definido como true. Isso ativa automaticamente as políticas de verificação de chave de API e token OAuth2 para o tráfego correspondente a esse gateway. Para testar, envie uma solicitação não autenticada para o serviço de amostra httpbin que você configurou ao verificar a configuração do gateway do Istio em Verificar a configuração do gateway do Istio.

1. Consiga o endereço IP do gateway:

   export GATEWAY_IP=$(kubectl get gateways.gateway.networking.k8s.io istio-gateway -n default -o=jsonpath='{.status.addresses[0].value}')
       

   echo $GATEWAY_IP
       

2. Envie uma solicitação para o endpoint /get configurado na sua HTTPRoute:

   curl http://$GATEWAY_IP/get -H "Host: example.httpbin.com" -v
       

3. Como defaultSecurityEnabled: true exige autenticação (como uma chave de API válida), a Apigee precisa rejeitar a solicitação com um erro de autenticação. A resposta será semelhante a esta:

   {"fault":{"faultstring":"Raising fault. Fault name : RF-insufficient-request-raise-fault","detail":{"errorcode":"steps.raisefault.RaiseFault"}}}
       

   Essa saída confirma que o APIMExtensionPolicy está ativo e que as políticas da Apigee estão sendo aplicadas pelo gateway do Istio.

A seguir

Saiba como criar produtos de API, desenvolvedores e apps para receber chaves de API para solicitações autenticadas:

• Como gerenciar produtos de API
• Como controlar o acesso às APIs registrando aplicativos
• Como registrar desenvolvedores de apps
• Como gerenciar o acesso às APIs usando chaves de API