Esta página se ha traducido con Cloud Translation API.

Operador de APIM: antes de empezar

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 antes de instalar y configurar el operador de gestión de APIs de Apigee para Kubernetes. Para obtener más información sobre las ventajas de usar el operador APIM, consulta el resumen del operador 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, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos en la organización:

Crea y gestiona el clúster de Google Kubernetes Engine (GKE): Administrador de contenedores (roles/container.admin)
Crear y gestionar cuentas de servicio: Administrador de cuentas de servicio (roles/iam.serviceAccountAdmin)
Crear y gestionar extensiones de servicio: Administrador de extensiones de servicio (roles/networkservices.serviceExtensionsAdmin)
Crear y gestionar grupos de puntos finales de red (NEGs): Administrador de instancias de Compute (roles/compute.instanceAdmin)
Crear y gestionar servicios backend: Administrador de balanceadores de carga de Compute (roles/compute.loadBalancerAdmin)
Crear y gestionar recursos de Apigee: Administrador de Apigee (roles/apigee.admin)

Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Tareas de configuración obligatorias

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

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

Puedes usar el operador APIM con una suscripción o una organización de Apigee con el modelo de Pay-as-you-go. Para obtener más información sobre cómo aprovisionar instancias de pago de Apigee, consulta el artículo Antes de empezar.
Instala Google Cloud CLI.

Una vez instalada la CLI de Google Cloud, 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 3.14.3 o posterior).
Crea un clúster de GKE con la versión 1.27 o una posterior de GKE con Workload Identity Federation para GKE y GKE Gateway habilitados.

Si tienes un clúster que cumpla estos requisitos, puedes saltarte este paso.

Workload Identity Federation para GKE está habilitado de forma predeterminada cuando se usa el modo Autopilot para crear y gestionar clústeres. Para obtener más información, consulta la descripción general de Autopilot.

Para ver los pasos necesarios para crear un clúster con Workload Identity Federation para GKE y GKE Gateway habilitados mediante Autopilot, consulta Desplegar Gateways.

Nota: Si usas el modo Estándar para crear y gestionar tus clústeres, debes habilitar manualmente Workload Identity Federation para GKE y GKE Gateway. Para obtener más información, consulta Workload Identity y Implementar pasarelas.
Despliega una GKE Gateway en tu clúster.
Puedes configurar y desplegar una pasarela interna o una pasarela externa para usarla con el operador de APIM. Si decides implementar una pasarela interna, se necesitan una subred de solo proxy y una VPC compartida. Para probar los pasos de esta guía, te recomendamos que implementes una pasarela externa. Para obtener más información, consulta los requisitos del controlador de GKE Gateway.
Nota: Si tienes previsto implementar más de una GKE Gateway en la misma región, ambas Gateways deben ser del mismo tipo (interna o externa). No puedes desplegar una pasarela interna y una externa en la misma región. En las configuraciones de ejemplo de esta guía se usa una pasarela externa.

Para desplegar la pasarela de GKE, sigue los pasos que se indican en Desplegar una pasarela externa. Cuando crees la pasarela, 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
```

Despliega una aplicación backend en tu clúster.

Para desplegar la aplicación backend expuesta por la pasarela global-ext-lb1 que has creado y desplegado, haz lo siguiente:

Crea un archivo 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 desplegar aplicaciones backend en clústeres de GKE, consulta Desplegar las aplicaciones de demostración.

Despliega 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 Implementar HTTPRoute (para Gateways internos) o Crear un HTTPRoute (para Gateways externos).

Para los fines de esta guía, te recomendamos que implementes una pasarela externa y una HTTPRoute siguiendo los pasos que se indican en Crear una HTTPRoute. Cuando crees el HTTPRoute, usa la siguiente configuración de yaml y sustituye HOST_NAME por el nombre de host que quieras 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

Aplica el archivo a tu clúster:

kubectl apply -f httproute.yaml

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

Siguientes pasos

Consulta cómo instalar el operador de APIM.