Esta página foi traduzida pela API Cloud Translation.

Criar um ApigeeBackendService

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

Confira a documentação da Apigee Edge.

Nesta página, descrevemos como criar um ApigeeBackendService e a extensão de tráfego necessária no gateway do Google Kubernetes Engine (GKE) em execução no seu cluster.

Essa abordagem é uma alternativa ao uso do APIMExtensionPolicy para identificar o plano de dados do Apigee como o ponto de decisão de política (PDP) do gateway do GKE. Quando você cria um ApigeeBackendService, o operador do Apigee para Kubernetes cria automaticamente um APIMExtensionPolicy com o mesmo nome e namespace do ApigeeBackendService. Esse é o APIMExtensionPolicy de suporte.

Recomendamos essa abordagem se você criar e gerenciar extensões de tráfego do Cloud Load Balancing e quiser adicionar a Apigee como uma extensão no recurso extensão de tráfego. É necessário usar o ApigeeBackendService se a extensão de tráfego da Apigee funcionar em conjunto com outras extensões de tráfego.

Antes de começar

Antes de começar esta tarefa, conclua as seguintes etapas:

Confirme se a implementação do GKE usa a versão 1.34.x ou mais recente.
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.
Observação:confirme se o gateway do GKE está implantado no namespace default. O ApigeeBackendService criado neste guia precisa ser implantado no mesmo namespace default, já que backendRef (usado para referenciar o ApigeeBackendService) e targetRef (usado para referenciar o gateway do GKE) não aceitam a especificação de um namespace.
Instale o operador da Apigee para Kubernetes. Consulte Instalar o operador do Apigee para Kubernetes para instruções de instalação.

Funções exigidas

Se você atribuiu os papéis necessários à sua conta de serviço, conforme descrito em Instalar o operador 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.

Criar o recurso ApigeeBackendService

Para configurar uma extensão de serviço de tráfego no gateway do GKE, crie dois recursos principais:

ApigeeBackendService:esse recurso personalizado especifica o plano de dados da Apigee como o ponto de decisão de política (PDP) e configura detalhes da rede para grupos de endpoints de rede (NEGs) do Private Service Connect (PSC).
GCPTrafficExtension:esse recurso da API Gateway do GKE define a cadeia de extensão, incluindo como o tráfego é direcionado para o ApigeeBackendService.

Crie um `ApigeeBackendService`

O recurso ApigeeBackendService especifica o plano de dados da Apigee como o PDP para um GCPTrafficExtension.

Para criar um ApigeeBackendService:

Crie um arquivo YAML chamado apigee-backend-service.yaml com o seguinte conteúdo:

# apigee-backend-service.yaml
kind: ApigeeBackendService
apiVersion:  apim.googleapis.com/v1
metadata:
  name: my-apigee-extension-backend-service
spec:
  apigeeEnv: ENV_NAME # optional for Apigee, required for hybrid
  defaultSecurityEnabled: SECURITY_ENABLED
  locations: # required field
  - name: REGION_NAME_1
    network: NETWORK_NAME_1
    subnet: SUBNET_NAME_1
  - name: REGION_NAME_2
    network: NETWORK_NAME_2
    subnet: SUBNET_NAME_2

Em que:

ENV_NAME é o ambiente da Apigee a ser usado. Isso é semelhante ao campo apigeeEnv no APIMExtensionPolicy. Esse campo é opcional para a Apigee e obrigatório para a híbrida.
SECURITY_ENABLED (opcional) especifica se as políticas padrão da Apigee para validação de chave de API e verificações de cota são ativadas automaticamente. O padrão é true se não for especificado.
REGION_NAME_1 especifica a região em que você implanta o gateway do GKE.
NETWORK_NAME_1 e SUBNET_NAME_1 especificam os URIs de recursos completos da rede e da sub-rede em que os NEGs do PSC são criados. Por exemplo, projects/my-project/global/networks/my-default e projects/my-project/regions/us-central1/subnetworks/my-default. Normalmente, são as mesmas da rede e da sub-rede do cluster do GKE.
REGION_NAME_2, NETWORK_NAME_2 e SUBNET_NAME_2 são opcionais. Eles são necessários se você implantar a extensão de tráfego da Apigee em várias regiões.

Aplique o arquivo YAML ao cluster no namespace default:
```
kubectl apply -f apigee-backend-service.yaml
```

Confirme se o ApigeeBackendService foi criado:

kubectl get apigeebackendservice

A saída será parecida com esta:

NAMESPACE   NAME                          STATE     ERRORMESSAGE
default     default-ext-lb1-apim-policy   CREATED

Quando você cria um ApigeeBackendService, o operador do Apigee para Kubernetes cria automaticamente um APIMExtensionPolicy com o mesmo nome e namespace do ApigeeBackendService. Esse é o APIMExtensionPolicy de suporte.

Se defaultSecurityEnabled estiver definido como true, o operador da Apigee para Kubernetes adicionará automaticamente a chave de API padrão e as políticas de cota ao APIMExtensionPolicy. Para adicionar outras políticas, consulte Adicionar políticas ao gateway do GKE.

Criar um recurso `GCPTrafficExtension`

O recurso GCPTrafficExtension define uma extensão para a Apigee e faz referência ao ApigeeBackendService criado na etapa anterior como backendRef. Para mais detalhes sobre como configurar um GCPTrafficExtension, consulte Configurar extensões de serviço.

O campo supportedEvents especifica quais partes do ciclo de vida de solicitação e resposta são expostas à extensão. O operador da Apigee para Kubernetes é compatível com os seguintes eventos:

RequestHeaders
RequestBody
RequestTrailers
ResponseHeaders
ResponseBody
ResponseTrailers

Para políticas que exigem inspeção ou modificação do corpo da solicitação ou da resposta (por exemplo, JSONThreatProtection), inclua RequestBody e ResponseBody na lista supportedEvents. Para mais informações sobre eventos compatíveis, consulte a documentação sobre extensões de tráfego do Cloud Load Balancing.

Para criar um GCPTrafficExtension:

Crie um arquivo YAML chamado gcp-traffic-extension.yaml com o seguinte conteúdo:

# gcp-traffic-extension.yaml
kind: GCPTrafficExtension
apiVersion: networking.gke.io/v1
metadata:
  name: my-apigee-extension
spec:
  targetRefs:
  - group: "gateway.networking.k8s.io"
    kind: Gateway
    name: GATEWAY_NAME  # Replace with your GKE Gateway name
  extensionChains:
  - name: EXTENSION_CHAIN_NAME
    matchCondition:
      celExpressions:
      - celMatcher: request.path.startsWith("/")
    extensions:
    - name: EXTENSION_NAME
      metadata:
        # This metadata label must match the name of the ApigeeBackendService
        apigee-extension-processor : APIGEE_BACKEND_SERVICE_NAME
      failOpen: false
      supportedEvents:
      - SUPPORTED_EVENT1
      - SUPPORTED_EVENT2
      timeout: 1s
      requestBodySendMode: FullDuplexStreamed
      backendRef: # References the ApigeeBackendService by kind and name
        kind: ApigeeBackendService
        name: APIGEE_BACKEND_SERVICE_NAME
        Port: 443

Em que:

GATEWAY_NAME é o nome do gateway do GKE a que a extensão se aplica.
EXTENSION_CHAIN_NAME é o nome da cadeia de extensão.
EXTENSION_NAME é o nome da extensão de serviço de tráfego.
APIGEE_BACKEND_SERVICE_NAME é o nome do ApigeeBackendService criado anteriormente. Esse rótulo dentro do bloco extensions precisa corresponder ao metadata.name do ApigeeBackendService criado anteriormente.
O campo supportedEvents especifica quais partes do ciclo de vida de solicitação e resposta são expostas à extensão. O operador da Apigee para Kubernetes oferece suporte aos seguintes eventos:
- RequestHeaders
- RequestBody
- RequestTrailers
- ResponseHeaders
- ResponseBody
- ResponseTrailers
Para políticas que exigem inspeção ou modificação do corpo da solicitação ou da resposta (por exemplo, JSONThreatProtection), inclua RequestBody e ResponseBody na lista supportedEvents. Para mais informações sobre eventos compatíveis, consulte a documentação sobre extensões de tráfego do Cloud Load Balancing.

Aplique o arquivo YAML ao cluster:

kubectl apply -f gcp-traffic-extension.yaml