Esta página foi traduzida pela API Cloud Translation.

Atualizar políticas de gerenciamento de APIs 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.

À medida que as necessidades de gerenciamento de API aumentam e mudam, talvez seja necessário adicionar novos serviços ao cluster ou atualizar as rotas e opções de entrada atuais. Esta página descreve como atualizar o cluster para concluir as seguintes tarefas:

Adicione um gateway e um HTTPRoute.
Atualizar um produto de API.
Crie um novo produto de API.
Crie um novo conjunto de operações de API.
Teste a nova configuração do gateway.

Antes de começar

Antes de começar esta tarefa, conclua as etapas descritas em Aplicar uma política com o operador do Apigee APIM para Kubernetes. Nesta página, presumimos que você tenha configurado um cluster do Google Kubernetes Engine (GKE), instalado o operador APIM do Apigee para Kubernetes, criado um gateway do Google Kubernetes Engine (GKE) e aplicado pelo menos uma política de gerenciamento de API ao gateway.

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.

Adicionar um gateway e um HTTPRoute

Nesta seção, você vai adicionar um novo gateway e um HTTPRoute ao cluster. Nos guias de tarefas anteriores, as configurações de exemplo usavam um gateway do GKE externo. Se vários gateways forem implantados na mesma região, eles precisarão ser do mesmo tipo (externo ou interno). Por esse motivo, a configuração de exemplo neste guia também vai usar um gateway externo.

O operador do APIM pode ser usado com gateways internos ou externos do GKE, mas não é possível implantar os dois tipos de gateways na mesma região.

Para adicionar um novo gateway e HTTPRoute ao cluster, siga estas etapas:

Configure um novo gateway externo do GKE. Para mais informações e etapas, consulte Implantar um gateway externo.
Crie um novo arquivo chamado gateway2.yaml no namespace apim.

Copie o conteúdo a seguir no novo arquivo:

# gateway2.yaml
apiVersion: gateway.networking.k8s.io/v1beta1
kind: Gateway
metadata:
  name: global-ext-lb2
  spec: 
  gatewayClassName: gke-l7-global-external-managed
  listeners:
  - name: https
    protocol: HTTPS
    allowedRoutes:
      kinds:
      - kind: HTTPRoute
      namespaces:
        from: All
    port: 443
    tls:
      options:
        networking.gke.io/pre-shared-certs: apigee-lb-new-cert-sept

Adicione uma nova HTTPRoute para /post ao mesmo arquivo, conforme destacado abaixo:

# http-route2.yaml
  apiVersion: gateway.networking.k8s.io/v1beta1
  kind: HTTPRoute
  metadata:
    name: http-bin-route-post
    namespace: http
  spec:
    parentRefs:
      - kind: Gateway
        name: global-ext-lb2
        namespace: default
    hostnames:
      - HOST_NAME_2
    rules:
    - matches:
      - path:
          type: PathPrefix
          value: "/post"
      backendRefs:
      - name: httpbin
        kind: Service
        port: 80
        namespace: http

Aplique o novo gateway e o HTTPRoute:
```
kubectl apply -f gateway2.yaml
```

Verifique o status da HTTPRoute usando o seguinte comando:

kubectl -n http get HttpRoute

A saída será semelhante a esta:

NAME             HOSTNAMES                                                  AGE
http-bin-route   ["my-hostname-2"]   12d

Verifique o status da gateway usando o seguinte comando:

kubectl get gateway global-ext-lb2

A saída será semelhante a esta:

NAME             CLASS                            ADDRESS        PROGRAMMED   AGE
global-ext-lb2   gke-l7-global-external-managed   34.54.193.92   True         11d

Confirme se a coluna Address contém um endereço IP válido e se o status de Programmed é True.

Descreva o gateway para garantir que a rota esteja anexada:
```
kubectl describe gateway global-ext-lb2
```

A saída será semelhante a esta:

...
Listeners:
  Attached Routes:  1
  Conditions:
    Last Transition Time:  2024-10-03T03:10:17Z
...

Confirme se o valor Attached Routes é 1.

Envie uma solicitação ao gateway para verificar se a rota está funcionando:
```
curl -X POST http://GATEWAY_IP_ADDRESS/post -H "Host: HOST_NAME"
```
Em que:
- GATEWAY_IP_ADDRESS é o endereço IP do gateway, conforme mostrado na coluna Address da resposta retornada na Etapa 7.
- HOST_NAME é o nome do host definido no HTTPRoute do gateway.

A saída será semelhante a esta:

  {
    "args": {}, 
    "headers": {
      "Accept": "*/*", 
      "Host": "apigee-apim-operator-test.apigee.net", 
      "User-Agent": "curl/8.7.1", 
      "X-Cloud-Trace-Context": "2bb8a80e29e80662ff9cb89971c447d9/13083106619927322701"
    }, 
    "origin": "67.164.1.10,34.54.193.72", 
    "url": "https://apigee-apim-operator-test.apigee.net/post"
  }

Crie uma nova política de extensão da APIM que faça referência ao HTTPRoute do novo gateway criado em uma etapa anterior:
1. Crie um novo arquivo chamado apim-policy2.yaml no namespace apim.
2. Copie o conteúdo a seguir no novo arquivo:
```
# apim-policy2.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: APIMExtensionPolicy
metadata:
  name: global-ext-lb2-apim-policy-2
  namespace: apim
spec:
  location: global
  failOpen: false
  timeout: 1000ms
  targetRef: # identifies the Gateway where the extension should be installed
    name: global-ext-lb2 
    kind: Gateway
    namespace: default
```
3. Aplique a nova política de extensão do APIM:
```
kubectl apply -f apim-policy2.yaml
```
  Depois que o arquivo é aplicado, o operador do APIM cria recursos de rede em segundo plano.
4. Confira o status da política de extensão do APIM:
```
kubectl -n apim get APIMExtensionPolicy
```
  A saída será semelhante a esta:
```
NAME                           STATE        ERRORMESSAGE
global-ext-lb2-apim-policy-2   RUNNING  
```
  Confirme se o valor STATE é RUNNING.
5. Aguarde cinco minutos para garantir que as mudanças sejam propagadas para todas as instâncias do balanceador de carga e, em seguida, use o comando a seguir para verificar se uma solicitação para o novo gateway falha:
```
curl -X POST http://GATEWAY_IP_ADDRESS/post -H "Host: HOSTNAME"
```
  Em que:
  - GATEWAY_IP_ADDRESS é o endereço IP do gateway obtido em uma etapa anterior.
  - 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 significa que a extensão de serviço para a Apigee está ativa e a chave de API e a verificação de token de acesso são aplicadas. Para conferir as etapas necessárias para criar um app de desenvolvedor, confira Testar a extensão de serviço do Apigee.

Atualizar um produto de API

Modifique um produto de API para fazer referência à nova política de extensão do APIM:

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

Copie o conteúdo a seguir no novo arquivo:

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

Aplique o novo arquivo do produto da API:
```
kubectl apply -f api-product-2.yaml
```
As mudanças vão levar cerca de três minutos para serem aplicadas em todo o cluster.

Neste exemplo, a seção EnforcementRefs do produto de API api-product-2 é atualizada para fazer referência a global-ext-lb1-apim-policy e global-ext-lb2-apim-policy, conforme mostrado nas partes destacadas do yaml.

Criar um produto de API

Crie um novo produto de API:

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

Copie o conteúdo a seguir no novo arquivo:

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

Aplique o novo arquivo do produto da API:
```
kubectl apply -f api-product-2.yaml
```
As mudanças vão levar cerca de três minutos para serem aplicadas em todo o cluster.

Neste exemplo, a seção EnforcementRefs do novo produto de API api-product-2 é criada para fazer referência a global-ext-lb2-apim-policy, conforme mostrado nas partes destacadas do yaml.

Criar um novo conjunto de operações de API

Crie um novo conjunto de operações de API:

Crie um novo arquivo chamado item-set-post.yaml no namespace apim.

Copie o conteúdo a seguir no novo arquivo:

# item-set-post.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: APIOperationSet
metadata:
  name: item-set-post
  namespace: apim
spec:
  apiProductRefs:
    - name: api-product-1
      kind: APIProduct
      group: apim.googleapis.com
      namespace: apim
  quota:
    limit: 1
    interval: 1
    timeUnit: minute
  restOperations:
    - name: PostItems
      path: "/post"
      methods:
      - POST

Aplique o novo arquivo de conjunto de operações da API:
```
kubectl apply -f item-set-post.yaml
```
As mudanças vão levar cerca de três minutos para serem aplicadas em todo o cluster.

Neste exemplo, o valor restOperations do novo conjunto de operações de API item-set-post é criado para fazer referência ao caminho /post, conforme mostrado nas partes destacadas do arquivo.

Testar a nova configuração do gateway

Para testar a nova configuração do gateway, envie a seguinte solicitação para o novo caminho /post:

curl -X POST http://GATEWAY_IP_ADDRESS/post -H "Host: HOST_NAME"

Em que:

GATEWAY_IP_ADDRESS é o endereço IP do gateway obtido em uma etapa anterior.
HOST_NAME é o nome do host definido no HTTPRoute do gateway.

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/post"
}

Resolver problemas

Se você tiver problemas ao atualizar e estender as políticas de gerenciamento de API usadas com o operador do APIM, consulte Resolver problemas do operador do APIM para encontrar soluções para erros comuns.

A seguir

Saiba como desinstalar o operador Apigee APIM para Kubernetes.
Saiba mais sobre as opções de implantação de gateways.