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.

Esta página descreve as etapas que você precisa concluir antes de instalar e configurar o operador APIM da Apigee para Kubernetes (pré-lançamento). Para saber mais sobre os benefícios do uso do 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 necessários para instalar e usar o Operador de APIM, peça ao administrador para conceder a você os seguintes papéis do IAM na organização:

Criar e gerenciar 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 da instância do Compute (roles/compute.instanceAdmin)
Crie e gerencie 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 por meio de papéis personalizados ou de outros papéis predefinidos.

Tarefas de configuração necessárias

Antes de instalar o operador do 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-14-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 console do Google Cloud.Acesse a página Instâncias no console do Google Cloud para selecionar uma instância e conferir os detalhes dela:
Acesse "Instâncias"

É possível usar o Operador do APIM com uma organização da Apigee de assinatura ou pagamento por uso. Para mais detalhes sobre o provisionamento de instâncias pagas da Apigee, consulte Antes de começar.
Instale a CLI do Google Cloud.

Depois de instalar a CLI do Google Cloud, 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 com a Federação de identidade da carga de trabalho para o GKE e o Gateway do GKE ativados.

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

Para saber 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 Implantar gateways.

Observação:se você estiver usando o modo padrão para criar e gerenciar clusters, será necessário ativar 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ária uma sub-rede somente proxy e uma VPC compartilhada. Para este guia, recomendamos que você implante uma gateway externa. Para mais informações, consulte os Requisitos do controlador de gateway do GKE.
Observação:se você planeja implantar mais de um gateway do GKE na mesma região, os dois gateways precisam ser do mesmo tipo (interno ou externo). Não é possível implantar um gateway interno e um gateway externo na mesma região. Os exemplos de configuração neste guia usam uma gateway externa.

Para implantar o gateway do GKE, siga as etapas descritas em Implantar um gateway externo. Ao criar a 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 implantar uma gateway externa e um HTTPRoute, seguindo as etapas em Criar um HTTPRoute. Ao criar o HTTPRoute, use a seguinte configuração yaml:

# 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:
    - apigee-apim-operator-test.apigee.net
  rules:
    - matches:
        - path:
            value: /
      backendRefs:
        - name: httpbin
          kind: Service
          port: 80
          namespace: http

Aplique o arquivo ao cluster:

kubectl apply -f httproute.yaml

Verifique se a configuração do gateway do GKE está funcionando conforme o 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 que 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. É possível extrair 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á 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": "http://apigee-apim-operator-test.apigee.net/get"
  }

A seguir

Saiba como instalar o operador do APIM.