Esta página foi traduzida pela API Cloud Translation.

Operador da APIM: antes de começar

Esta página aplica-se ao Apigee, mas não ao Apigee Hybrid.

Veja a documentação do Apigee Edge.

Esta página descreve os passos que tem de concluir antes de poder instalar e configurar o operador APIM do Apigee para Kubernetes. Para saber mais sobre as vantagens de usar o operador APIM, consulte o artigo Vista geral do operador APIM do Apigee para Kubernetes.

Funções necessárias

Para receber as autorizações de que precisa para configurar os recursos necessários para instalar e usar o operador da APIM, peça ao seu administrador que lhe conceda as seguintes funções de IAM na organização:

Criar e gerir o cluster do Google Kubernetes Engine (GKE): Administrador de contentores (roles/container.admin)
Criar e gerir contas de serviço: Administrador da conta de serviço (roles/iam.serviceAccountAdmin)
Crie e faça a gestão de extensões de serviços: Administrador de extensões de serviços (roles/networkservices.serviceExtensionsAdmin)
Criar e gerir grupos de pontos finais de rede (NEGs): Administrador de instâncias de computação (roles/compute.instanceAdmin)
Criar e gerir serviços de back-end: Administrador do balanceador de carga do Compute (roles/compute.loadBalancerAdmin)
Criar e gerir recursos do Apigee: Administrador do Apigee (roles/apigee.admin)

Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

Tarefas de configuração necessárias

Antes de instalar o operador APIM, certifique-se de que conclui as seguintes tarefas para configurar os recursos de que precisa para usar a funcionalidade:

Aprovisione uma instância do Apigee com a versão 1-15-0-apigee-4 ou posterior.
Pode ver as versões das instâncias na página Detalhes da instância da IU do Apigee na Google Cloud consola.Aceda à página Instâncias na Google Cloud consola para selecionar uma instância e ver os respetivos detalhes:
Aceda a Instâncias

Pode usar o operador da API Management com uma subscrição ou uma organização do Apigee de Pay-as-you-go. Para mais detalhes sobre o aprovisionamento de instâncias pagas do Apigee, consulte o artigo Antes de começar.
Instale a CLI do Google Cloud.

Depois de instalar a CLI Google Cloud, execute o comando gcloud components update para obter os componentes gcloud mais recentes.
Instale e configure a ferramenta de linha de comandos kubectl.
Instale o Helm (versão v3.14.3 ou posterior).
Crie um cluster do GKE com a versão 1.27 ou posterior do GKE com a Workload Identity Federation para o GKE e o GKE Gateway ativados.

Se tiver um cluster existente que cumpra estes requisitos, pode ignorar este passo.

A Workload Identity Federation para o GKE está ativada por predefinição quando usa o modo Autopilot para criar e gerir os seus clusters. Para mais informações, consulte o artigo Vista geral do Autopilot.

Para ver os passos necessários para criar um novo cluster com a Workload Identity Federation para o GKE e o GKE Gateway ativados através do Autopilot, consulte o artigo Implementar gateways.

Nota: se estiver a usar o modo Standard para criar e gerir os seus clusters, tem de ativar manualmente a Workload Identity Federation para o GKE e o GKE Gateway. Para mais informações, consulte os artigos Identidade da carga de trabalho e Implementar gateways.
Implemente um GKE Gateway no seu cluster.
Pode optar por configurar e implementar um gateway interno ou um gateway externo para usar com o operador da APIM. Se optar por implementar um gateway interno, é necessária uma sub-rede apenas de proxy e uma VPC partilhada. Para testar os passos neste guia, recomendamos que implemente um gateway externo. Para mais informações, consulte os requisitos do controlador do GKE Gateway.
Nota: se planear implementar mais do que um GKE Gateway na mesma região, ambos os Gateways têm de ser do mesmo tipo (interno ou externo). Não pode implementar um gateway interno e um gateway externo na mesma região. As configurações de exemplo neste guia usam um gateway externo.

Para implementar o GKE Gateway, siga os passos descritos no artigo Implemente um gateway externo. Quando criar o Gateway, use a seguinte configuração 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 ficheiro ao cluster:
```
kubectl apply -f gateway.yaml
```

Implemente uma aplicação de back-end no seu cluster.

Para implementar a aplicação de back-end exposta pelo gateway global-ext-lb1 que criou e implementou:

Crie um novo ficheiro com o nome target.yaml.

Copie o seguinte conteúdo para o novo ficheiro:

# 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 cluster:
```
kubectl apply -f target.yaml
```

Para mais informações sobre a implementação de aplicações de back-end em clusters do GKE, consulte o artigo Implemente as aplicações de demonstração.

Implemente o recurso HTTPRoute no seu cluster para mapear o tráfego do Gateway para o seu serviço de back-end.

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

Para os fins deste guia, recomendamos que implemente um gateway externo e um HTTPRoute, seguindo os passos em Crie um HTTPRoute. Quando criar o HTTPRoute, use a seguinte configuração yaml, substituindo HOST_NAME pelo nome do anfitrião que 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 ficheiro ao cluster:

kubectl apply -f httproute.yaml

Verifique a configuração do GKE Gateway para confirmar que está a funcionar conforme esperado.

Obtenha os detalhes do gateway através do seguinte comando:

kubectl get gateway global-ext-lb1

O resultado deve ser semelhante ao seguinte:

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

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

Descreva o gateway para confirmar que o trajeto está anexado:
```
kubectl describe gateway global-ext-lb1
```
O resultado deve ser semelhante ao seguinte:
```
...
  Listeners:
    Attached Routes:  1
    Conditions:
      Last Transition Time:  2024-10-03T03:10:17Z
...
```
Confirme se o valor de Attached Routes é 1, o que indica que a rota está associada.

Envie um pedido ao gateway:

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

Onde:

GATEWAY_IP_ADDRESS é o endereço IP do gateway. Pode obter o endereço IP do gateway através do 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 de anfitrião definido no HTTPRoute do gateway. Pode obter o HOST_NAME através do 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 deve ser semelhante à seguinte:

  {
    "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"
  }

O que se segue?

Saiba como instalar o operador APIM.