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 suas necessidades de gerenciamento de API crescem e mudam, talvez seja necessário adicionar novos serviços ao cluster ou atualizar rotas e opções de entrada atuais. Nesta página, descrevemos como atualizar o cluster para concluir as seguintes tarefas:

Adicione um novo gateway e HTTPRoute.
Atualize um produto de API.
Crie um 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 da API Apigee para Kubernetes. Nesta página, presumimos que você já configurou um cluster do Google Kubernetes Engine (GKE), instalou o operador da API do Apigee para Kubernetes, criou um gateway do Google Kubernetes Engine (GKE) e aplicou pelo menos uma política de gerenciamento de API ao gateway.

Funções exigidas

Se você atribuiu os papéis necessários à sua conta de serviço conforme descrito em Instalar o operador de APIM do Apigee para Kubernetes, não são necessários outros papéis ou permissões 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) no Kubernetes. Para mais informações, consulte Autorizar ações em clusters usando o controle de acesso baseado em papéis.

Adicionar um novo gateway e HTTPRoute

Nesta seção, você vai adicionar um novo gateway e HTTPRoute ao cluster. Em 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 (externos ou internos). Por isso, a configuração de exemplo neste guia também usa um gateway externo.

O operador da API Manager 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 recurso SslCertificate global gerenciado pelo Google:
```
gcloud compute ssl-certificates create CERT_NAME \
  --domains=HOST_NAME \
  --global
```
Em que:
- CERT_NAME é o nome do certificado que você quer criar.
- HOST_NAME_2 é o nome do host do novo gateway.
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: CERT_NAME

Adicione um novo 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 HTTPRoute:
```
kubectl apply -f gateway2.yaml
```

Verifique o status do 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 do 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 -k -X POST https://GATEWAY_IP_ADDRESS/post -H "Host: HOST_NAME_2"
```
Em que:
- GATEWAY_IP_ADDRESS é o endereço IP do gateway, conforme mostrado na coluna Address da resposta retornada na Etapa 7.
- HOST_NAME_2 é 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 política de extensão do APIM que faça referência à 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/v1
kind: APIMExtensionPolicy
metadata:
  name: global-ext-lb2-apim-policy-2
  namespace: apim
spec:
  location: global
  failOpen: false
  timeout: 1000ms
  defaultSecurityEnabled: true
  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. Verifique 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 use o comando a seguir para verificar se uma solicitação ao novo gateway falha:
```
curl -k -X POST https://GATEWAY_IP_ADDRESS/post -H "Host: HOST_NAME_2"
```
  Em que:
  - GATEWAY_IP_ADDRESS é o endereço IP do gateway obtido em uma etapa anterior.
  - HOST_NAME_2 é 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 que a verificação da chave de API e do token de acesso é aplicada. Para conferir as etapas necessárias para criar um app de desenvolvedor, conseguir uma chave de API e testar o novo gateway com a chave, consulte Testar a extensão de serviço do Apigee.

Atualizar um produto de API

Modifique um produto de API existente para referenciar a nova política de extensão da 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/v1
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 de produto da API:
```
kubectl apply -f api-product-2.yaml
```
As mudanças vão levar aproximadamente 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 referenciar 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 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/v1
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 de produto da API:
```
kubectl apply -f api-product-2.yaml
```
As mudanças vão levar aproximadamente 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/v1
kind: APIOperationSet
metadata:
  name: item-set-post
  namespace: apim
spec:
  apiProductRefs:
    - name: api-product-2
      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 aproximadamente 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 referenciar o 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 -k -X POST https://GATEWAY_IP_ADDRESS/post -H "Host: HOST_NAME_2"

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ê encontrar problemas ao atualizar e estender as políticas de gerenciamento de API usadas com o operador APIM, consulte Solução de problemas do operador APIM para encontrar soluções para erros comuns.

A seguir

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

Atualizar políticas de gerenciamento de APIs com o operador Apigee APIM para Kubernetes Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Funções exigidas

Adicionar um novo gateway e HTTPRoute

Atualizar um produto de API

Criar um produto de API

Criar um novo conjunto de operações de API

Testar a nova configuração do gateway

Resolver problemas

A seguir

Atualizar políticas de gerenciamento de APIs com o operador Apigee APIM para Kubernetes