Se usó la API de Cloud Translation para traducir esta página.

Operador de APIM: Antes de comenzar

Esta página se aplica a Apigee, pero no a Apigee Hybrid.

Consulta la documentación de Apigee Edge.

En esta página, se describen los pasos que debes completar para instalar y configurar el operador de APIM de Apigee para Kubernetes (versión preliminar). Para obtener más información sobre los beneficios de usar el operador de APIM, consulta la descripción general del operador de APIM de Apigee para Kubernetes.

Roles obligatorios

Para obtener los permisos que necesitas para configurar los recursos necesarios para instalar y usar el operador de APIM, pídele a tu administrador que te otorgue los siguientes roles de IAM en la organización:

Crea y administra el clúster de Google Kubernetes Engine (GKE): Administrador de contenedores (roles/container.admin)
Crear y administrar cuentas de servicio: Administrador de cuentas de servicio (roles/iam.serviceAccountAdmin)
Crear y administrar extensiones del servicio: Administrador de extensiones del servicio (roles/networkservices.serviceExtensionsAdmin)
Crear y administrar grupos de extremos de red (NEG): Administrador de instancias de Compute (roles/compute.instanceAdmin)
Crear y administrar servicios de backend: Administrador de balanceador de cargas de Compute (roles/compute.loadBalancerAdmin)
Crear y administrar recursos de Apigee: Administrador de Apigee (roles/apigee.admin)

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

Tareas de configuración obligatorias

Antes de instalar el operador de APIM, asegúrate de completar las siguientes tareas para configurar los recursos que necesitas para usar la función:

Aprovisiona una instancia de Apigee con la versión 1-14-0-apigee-4 o una posterior.
Puedes ver las versiones de las instancias en la página Detalles de la instancia de la IU de Apigee en la consola de Google Cloud.Ve a la página Instancias en la consola de Google Cloud para seleccionar una instancia y ver sus detalles:
Ir a Instancias

Puedes usar APIM Operator con una organización de Apigee de suscripción o pago por uso. Para obtener más detalles sobre el aprovisionamiento de instancias pagadas de Apigee, consulta Antes de comenzar.
Instala Google Cloud CLI.

Después de instalar Google Cloud CLI, ejecuta el comando gcloud components update para obtener los componentes de gcloud más recientes.
Instala y configura la herramienta de línea de comandos kubectl.
Instala Helm (versión v3.14.3 o posterior).
Crea un clúster de GKE con la federación de identidades para cargas de trabajo para GKE y la puerta de enlace de GKE habilitadas.

La federación de identidades para cargas de trabajo para GKE está habilitada de forma predeterminada cuando usas el modo Autopilot para crear y administrar tus clústeres. Para obtener más información, consulta Descripción general de Autopilot.

Si deseas conocer los pasos necesarios para crear un clúster nuevo con Workload Identity Federation for GKE y la puerta de enlace de GKE habilitadas con Autopilot, consulta Cómo implementar puertas de enlace.

Nota: Si usas el modo estándar para crear y administrar tus clústeres, debes habilitar de forma manual la federación de identidades para cargas de trabajo para GKE y la puerta de enlace de GKE. Para obtener más información, consulta Workload Identity y Implementa puertas de enlace.
Implementa una puerta de enlace de GKE en tu clúster.
Puedes configurar e implementar una puerta de enlace interna o una puerta de enlace externa para usar con el operador de APIM. Si decides implementar una puerta de enlace interna, se requiere una subred de solo proxy y una VPC compartida. Para los fines de esta guía, te recomendamos que implementes una puerta de enlace externa. Para obtener más información, consulta los requisitos del controlador de puerta de enlace de GKE.
Nota: Si planeas implementar más de una puerta de enlace de GKE en la misma región, ambas deben ser del mismo tipo (interna o externa). No puedes implementar una puerta de enlace interna y una puerta de enlace externa en la misma región. En las configuraciones de ejemplo de esta guía, se usa una puerta de enlace externa.

Para implementar la puerta de enlace de GKE, sigue los pasos que se describen en Implementa una puerta de enlace externa. Cuando crees la puerta de enlace, usa la siguiente configuración 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
```
Aplica el archivo a tu clúster:
```
kubectl apply -f gateway.yaml
```

Implementa una aplicación de backend en tu clúster.

Para implementar la aplicación de backend que expone la puerta de enlace de global-ext-lb1 que creaste y que implementaste, haz lo siguiente:

Crea un archivo nuevo llamado target.yaml.

Copia el siguiente contenido en el archivo nuevo:

# 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

Aplica la configuración a tu clúster:
```
kubectl apply -f target.yaml
```

Para obtener más información sobre cómo implementar aplicaciones de backend en clústeres de GKE, consulta Implementa las aplicaciones de demostración.

Implementa el recurso HTTPRoute en tu clúster para asignar el tráfico de la puerta de enlace a tu servicio de backend.

Para obtener más información sobre el recurso HTTPRoute, consulta Cómo implementar HTTPRoute (para puertas de enlace internas) o Cómo crear un HTTPRoute (para puertas de enlace externas).

Para los fines de esta guía, te recomendamos que implementes una puerta de enlace y una HTTPRoute externas siguiendo los pasos que se indican en Crea una HTTPRoute. Cuando crees la HTTPRoute, usa la siguiente configuración de 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

Aplica el archivo a tu clúster:

kubectl apply -f httproute.yaml

Verifica la configuración de GKE Gateway para confirmar que funcione según lo esperado.
1. Obtén los detalles de la puerta de enlace con el siguiente comando:
```
kubectl get gateway global-ext-lb1
```
  El resultado debería ser similar al ejemplo siguiente:
```
NAME             CLASS                            ADDRESS        PROGRAMMED   AGE
global-ext-lb1   gke-l7-global-external-managed   34.54.193.72   True         11d
```
  Confirma que se haya asignado una dirección IP a la puerta de enlace y que el valor de PROGRAMMED sea True.
2. Describe la puerta de enlace para confirmar que la ruta esté adjunta:
```
kubectl describe gateway global-ext-lb1
```
  El resultado debería ser similar al siguiente:
```
...
  Listeners:
    Attached Routes:  1
    Conditions:
      Last Transition Time:  2024-10-03T03:10:17Z
...
```
  Confirma que el valor de Attached Routes sea 1, lo que indica que la ruta está adjunta.
3. Envía una solicitud a la puerta de enlace:
```
curl http://GATEWAY_IP_ADDRESS/get \
    -H "Host: HOST_NAME"
```
  Aquí:
  - GATEWAY_IP_ADDRESS es la dirección IP de la puerta de enlace. Puedes recuperar la dirección IP de la puerta de enlace con el siguiente comando, en el que GATEWAY_NAME es el nombre de la puerta de enlace:
```
kubectl get gateways.gateway.networking.k8s.io GATEWAY_NAME -o=jsonpath="{.status.addresses[0].value}"
```
  - HOST_NAME es el nombre de host definido en el HTTPRoute de la puerta de enlace. Puedes recuperar el HOST_NAME con el siguiente 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"
```
  La respuesta debería ser similar a la siguiente:
```
  {
    "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"
  }
```
  Nota: Los cambios aplicados pueden tardar hasta cinco minutos en propagarse. Si no ves el resultado esperado, espera unos minutos y vuelve a intentarlo.

¿Qué sigue?

Obtén más información para instalar el operador de APIM.