Esta página foi traduzida pela API Cloud Translation.

Operador do APIM: antes de começar

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

Confira a documentação da Apigee Edge.

Nesta página, descrevemos as etapas que você precisa concluir antes de instalar e configurar o operador da APIM do Apigee para Kubernetes. Para saber mais sobre os benefícios de usar o operador APIM, consulte Visão geral do operador APIM do Apigee para Kubernetes.

Funções exigidas

Para receber as permissões necessárias para configurar os recursos exigidos para instalar e usar o operador do APIM, peça ao administrador para conceder a você os seguintes papéis do IAM na organização:

Crie e gerencie o cluster do Google Kubernetes Engine (GKE): Administrador de contêineres (roles/container.admin)
Criar e gerenciar contas de serviço: Administrador da conta de serviço (roles/iam.serviceAccountAdmin)
Criar e gerenciar extensões de serviço: Administrador de extensões de serviço (roles/networkservices.serviceExtensionsAdmin)
Criar e gerenciar grupos de endpoints de rede (NEGs): Administrador de instâncias do Compute (roles/compute.instanceAdmin)
Criar e gerenciar serviços de back-end: Administrador do balanceador de carga do Compute (roles/compute.loadBalancerAdmin)
Criar e gerenciar recursos da Apigee: Administrador da Apigee (roles/apigee.admin)

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.

Tarefas de configuração obrigatórias

Antes de instalar o operador da APIM, conclua as seguintes tarefas para configurar os recursos necessários para usar o recurso:

Provisione uma instância do Apigee usando a versão 1-15-0-apigee-4 ou mais recente.
É possível conferir as versões da instância na página Detalhes da instância da interface da Apigee no Google Cloud console.Acesse a página Instâncias no Google Cloud console para selecionar uma instância e conferir os detalhes dela:
Acesse "Instâncias"

Você pode usar o operador da APIM com uma organização da Apigee por assinatura ou Pay-as-you-go. Para mais detalhes sobre o provisionamento de instâncias pagas da Apigee, consulte Antes de começar.
Instale a Google Cloud CLI.

Depois de instalar a Google Cloud CLI, execute o comando gcloud components update para receber os componentes mais recentes da gcloud.
Instale e configure a ferramenta de linha de comando kubectl.
Instale o Helm (versão v3.14.3 ou mais recente).
Crie um cluster do GKE usando a versão 1.27 ou mais recente com a federação de identidade da carga de trabalho para o GKE e o GKE Gateway ativados.

Se você já tiver um cluster que atenda a esses requisitos, pule esta etapa.

A federação de identidade da carga de trabalho do GKE é ativada por padrão ao usar o modo Autopilot para criar e gerenciar seus clusters. Para mais informações, consulte a Visão geral do Autopilot.

Para conferir as etapas necessárias para criar um cluster com a Federação de identidade da carga de trabalho para o GKE e o GKE Gateway ativados usando o Autopilot, consulte Como implantar gateways.

Observação:se você estiver usando o modo Standard para criar e gerenciar seus clusters, ative manualmente a federação de identidade da carga de trabalho para o GKE e o GKE Gateway. Para mais informações, consulte Identidade da carga de trabalho e Como implantar gateways.
Implante um gateway do GKE no cluster.
É possível configurar e implantar um gateway interno ou um gateway externo para usar com o operador do APIM. Se você optar por implantar um gateway interno, será necessário ter uma sub-rede somente proxy e uma VPC compartilhada. Para testar as etapas deste guia, recomendamos implantar um gateway externo. Para mais informações, consulte Requisitos do controlador de gateway do GKE.
Observação:se você planeja implantar mais de um gateway do GKE na mesma região, ambos precisam ser do mesmo tipo (interno ou externo). Não é possível implantar um gateway interno e um externo na mesma região. As configurações de exemplo neste guia usam um gateway externo.

Para implantar o gateway do GKE, siga as etapas descritas em Implantar um gateway externo. Ao criar o gateway, use a seguinte configuração de yaml:
```
# gateway.yaml
kind: Gateway
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: global-ext-lb1
  namespace: default
spec:
  gatewayClassName: gke-l7-global-external-managed
  listeners:
    - name: http
      protocol: HTTP
      allowedRoutes:
        kinds:
          - kind: HTTPRoute
        namespaces:
          from: All
      port: 80
```
Aplique o arquivo ao cluster:
```
kubectl apply -f gateway.yaml
```

Implante um aplicativo de back-end no cluster.

Para implantar o aplicativo de back-end exposto pelo gateway global-ext-lb1 que você criou e implantou:

Crie um novo arquivo denominado target.yaml.

Copie o conteúdo a seguir no novo arquivo:

# target.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: http
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: httpbin
  namespace: http
---
apiVersion: v1
kind: Service
metadata:
  name: httpbin
  namespace: http
  labels:
    app: httpbin
    service: httpbin
spec:
  type: LoadBalancer
  ports:
    - name: https
      port: 80
      targetPort: 80
  selector:
    app: httpbin
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: httpbin
  namespace: http
spec:
  replicas: 1
  selector:
    matchLabels:
      app: httpbin
      version: v1
  template:
    metadata:
      labels:
        app: httpbin
        version: v1
    spec:
      serviceAccountName: httpbin
      containers:
        - image: docker.io/kennethreitz/httpbin
          imagePullPolicy: IfNotPresent
          name: httpbin
          ports:
            - containerPort: 80
          resources:
            requests:
              cpu: 1
              memory: 1024Mi
            limits:
              cpu: 1
              memory: 1024Mi

Aplique a configuração ao seu cluster:
```
kubectl apply -f target.yaml
```

Para mais informações sobre como implantar aplicativos de back-end em clusters do GKE, consulte Implantar os aplicativos de demonstração.

Implante o recurso HTTPRoute no cluster para mapear o tráfego do gateway para o serviço de back-end.

Para mais informações sobre o recurso HTTPRoute, consulte Implantar o HTTPRoute (para gateways internos) ou Criar um HTTPRoute (para gateways externos).

Para os fins deste guia, recomendamos que você implante um gateway externo e um HTTPRoute seguindo as etapas em Criar um HTTPRoute. Ao criar o HTTPRoute, use a seguinte configuração yaml, substituindo HOST_NAME pelo nome do host que você quer usar:

# httproute.yaml
kind: HTTPRoute
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: http-bin-route
  namespace: http
spec:
  parentRefs:
    - kind: Gateway
      name: global-ext-lb1
      namespace: default
  hostnames:
    - HOST_NAME
  rules:
    - matches:
        - path:
            value: /
      backendRefs:
        - name: httpbin
          kind: Service
          port: 80
          namespace: http

Aplique o arquivo ao cluster:

kubectl apply -f httproute.yaml

Verifique a configuração do gateway do GKE para confirmar se ele está funcionando como esperado.

Receba os detalhes do gateway usando o seguinte comando:

kubectl get gateway global-ext-lb1

A saída será semelhante a:

NAME             CLASS                            ADDRESS        PROGRAMMED   AGE
global-ext-lb1   gke-l7-global-external-managed   34.54.193.72   True         11d

Confirme se um endereço IP foi atribuído ao gateway e se o valor de PROGRAMMED é True.

Descreva o gateway para confirmar se a rota está anexada:
```
kubectl describe gateway global-ext-lb1
```
A saída será parecida com esta:
```
...
  Listeners:
    Attached Routes:  1
    Conditions:
      Last Transition Time:  2024-10-03T03:10:17Z
...
```
Confirme se o valor de Attached Routes é 1, indicando que a rota está anexada.

Envie uma solicitação para o gateway:

curl http://GATEWAY_IP_ADDRESS/get \
    -H "Host: HOST_NAME"

Em que:

GATEWAY_IP_ADDRESS é o endereço IP do gateway. Recupere 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. É possível recuperar o HOST_NAME usando o seguinte comando:
```
kubectl get HTTPRoute HTTPROUTE_NAME -n NAMESPACE
```

For example:

curl http://34.54.193.72/get \
-H "Host: apigee-apim-operator-test.apigee.net"

A resposta será assim:

  {
    "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": "http://apigee-apim-operator-test.apigee.net/get"
  }

A seguir

Saiba como instalar o operador da APIM.