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

Instalar el operador de Apigee para Kubernetes en Apigee Hybrid

Esta página se aplica a Apigee y Apigee Hybrid.

Consulta la documentación de Apigee Edge.

En esta página se describen los pasos necesarios para instalar y configurar el operador de Apigee para Kubernetes en Apigee Hybrid. Para obtener más información sobre las ventajas de usar Apigee Operator para Kubernetes, consulta la descripción general de Apigee Operator para Kubernetes.

Si no usas Apigee Hybrid, consulta Instalar el operador de Apigee para Kubernetes para instalar el operador de Apigee para Kubernetes en Apigee.

Antes de empezar

Antes de empezar, asegúrate de que tienes lo siguiente:

Roles obligatorios

Para obtener los permisos que necesitas para configurar los recursos necesarios para instalar y usar el operador de Apigee para Kubernetes, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos en la organización:

Crear y gestionar cuentas de servicio: administrador de cuentas de servicio (roles/iam.serviceAccountAdmin)
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 Apigee para Kubernetes, asegúrate de completar las siguientes tareas para configurar los recursos que necesitas para usar la función:

Instala Apigee Hybrid con la versión 1.15.0 o una posterior. Consulta Información general para obtener instrucciones sobre cómo instalar Apigee Hybrid.
Crea un clúster de Kubernetes en un proveedor de servicios en la nube que admita Istio Gateway, como Google Cloud, Azure o Amazon.
Nota: Las instrucciones de estos procedimientos están diseñadas para funcionar con instalaciones en cualquier proveedor que admita Istio Gateway. Los pasos que usan gcloud son para comunicarse con el Google Cloud proyecto que contiene tu instancia de Apigee hybrid.

Instala Istio Gateway en tu clúster de K8s:

En el caso de los clústeres de GKE:

kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.1.0/standard-install.yaml
curl -L https://istio.io/downloadIstio | sh -
cd 1.6.11-asm.1
export PATH=$PWD/bin:$PATH
istioctl install --set profile=minimal --set values.global.platform=gke -y

En el caso de los clústeres de otros proveedores:

kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.1.0/standard-install.yaml
curl -L https://istio.io/downloadIstio | sh -
cd 1.6.11-asm.1
export PATH=$PWD/bin:$PATH
istioctl install --set profile=minimal -y

Despliega Istio Gateway en tu clúster de Kubernetes.

Crea un archivo llamado gateway.yaml con el siguiente contenido para desplegar la pasarela de Istio:

#gateway.yaml
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: istio-gateway
  namespace: default
  annotations:
    service.beta.kubernetes.io/port_80_health-probe_protocol: tcp
spec:
  gatewayClassName: istio
  listeners:
  - name: default
    hostname: "*.httpbin.com"
    port: 80
    protocol: HTTP
    allowedRoutes:
      namespaces:
        from: All

Aplica el archivo a tu clúster con el siguiente comando:
```
kubectl apply -f gateway.yaml
```

Verificar la configuración de la pasarela de Istio (opcional)

Para los fines de esta guía, te recomendamos que implementes una aplicación httpbin de ejemplo en el espacio de nombres predeterminado para probar la pasarela que has implementado.

Despliega una aplicación backend en tu clúster de Kubernetes para probar la pasarela.
1. Crea un archivo llamado target.yaml con el siguiente contenido:
```
kubectl apply -f - <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
  name: httpbin
---
apiVersion: v1
kind: Service
metadata:
  name: httpbin
  labels:
    app: httpbin
    service: httpbin
spec:
  ports:
  - name: http
    port: 8000
    targetPort: 8080
  selector:
    app: httpbin
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: httpbin
spec:
  replicas: 1
  selector:
    matchLabels:
      app: httpbin
      version: v1
  template:
    metadata:
      labels:
        app: httpbin
        version: v1
    spec:
      serviceAccountName: httpbin
      containers:
      - image: docker.io/mccutchen/go-httpbin:v2.15.0
        imagePullPolicy: IfNotPresent
        name: httpbin
        ports:
        - containerPort: 8080
EOF
```
  Nota: También puedes guardar las líneas entre las etiquetas <<EOF y EOF en un archivo llamado target.yaml. A continuación, aplica la configuración a tu clúster con el siguiente comando:
```
kubectl apply -f target.yaml
```
2. Despliega el recurso HTTPRoute en tu clúster para asignar el tráfico de la puerta de enlace a tu servicio de backend.
  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.
  
  Para obtener más información sobre el recurso HTTPRoute, consulta Desplegar el recurso HTTPRoute (para Gateways internos) o Crear un recurso HTTPRoute (para Gateways externos).
  1. Crea un HTTPRoute siguiendo las instrucciones de crear el HTTPRoute con la siguiente configuración de YAML:
```
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: http-bin-route
  namespace: default
spec:
  parentRefs:
  - name: istio-gateway
    namespace: default
  hostnames: ["example.httpbin.com"]
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /get
    backendRefs:
    - name: httpbin
      port: 8000
```
  2. Aplica el archivo a tu clúster:
```
kubectl apply -f httproute.yaml
```
3. 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
istio-gateway   istio   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 istio-gateway
```
    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 Rutas asociadas es 1, lo que indica que la ruta está asociada.
  3. Enviar una solicitud a la pasarela
```
curl http://GATEWAY_IP_ADDRESS/get \
  -H "Host: example.httpbin.com"
```
    Donde GATEWAY_IP_ADDRESS es la dirección IP de la pasarela. Puede 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.value}"
```
    Por ejemplo:
```
curl http://34.54.193.72/get -H "Host: example.httpbin.com"
```
    La respuesta debería ser similar a la siguiente:
```
{
    "args": {},
    "headers": {
      "Accept": "*/*",
      "Host": "http://example.httpbin.com",
      "User-Agent": "curl/8.7.1",
      "X-Cloud-Trace-Context": "2bb8a80e29e80662ff9cb89971c447d9/13083106619927322701"
    },
    "origin": "67.164.1.10,34.54.193.72",
    "url": "http://example.httpbin.com/get"
}
```
Instalar el operador de Apigee para Kubernetes

En este procedimiento se describen los pasos necesarios para instalar y configurar el operador de Apigee para Kubernetes.
Instalar y configurar el operador de Apigee para Kubernetes

En las siguientes secciones se describen los pasos necesarios para instalar y configurar el operador de Apigee para Kubernetes:
Establece variables de entorno:

En el Google Cloud proyecto que contiene tu instancia de Apigee, usa el siguiente comando para definir variables de entorno:
```
export PROJECT_ID=PROJECT_ID
export APIGEE_ORG=APIGEE_ORG
```
Donde:
- PROJECT_ID es el ID del proyecto con tu instancia de Apigee Hybrid.
- APIGEE_ORG es el nombre de la organización de tu instancia de Apigee Hybrid.
Confirma que las variables de entorno se han definido correctamente con el siguiente comando:
```
echo $PROJECT_ID $APIGEE_ORG
```
Crear y configurar la cuenta de servicio de APIM

Crea una cuenta de servicio para conectarte al plano de configuración de Apigee Hybrid.
1. Crea la apigee-apim-gsacuenta de servicio para conectarte a los Google Cloud servicios
2. Asigna el rol de administrador de Apigee a la cuenta de servicio que has creado con el siguiente comando. Este rol es necesario para crear y gestionar recursos de Apigee.
```
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
  --role "roles/apigee.admin"
```
3. Descarga el archivo de clave JSON correspondiente a la cuenta de servicio.
  1. Crea y descarga el archivo de clave $PROJECT_ID-apigee-apim-gsa.json con el siguiente comando:
```
gcloud iam service-accounts keys create $PROJECT_ID-apigee-apim-gsa.json \
  --iam-account=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com
  --project=$PROJECT_ID
        
```
  2. Comprueba que el archivo se haya descargado correctamente:
```
ls $PROJECT_ID-apigee-apim-gsa.json
        
```
Instalar el operador de Apigee para Kubernetes

Instala las definiciones de recursos personalizados (CRDs) de Kubernetes y el operador de Apigee para Kubernetes:
1. Crear un espacio de nombres para el operador de Apigee para Kubernetes
```
kubectl create namespace apim
```
2. Instala las definiciones de recursos personalizados (CRDs) del operador de Apigee para Kubernetes:
```
helm install apigee-apim-crds -n apim \
  oci://us-docker.pkg.dev/apigee-release/apigee-k8s-tooling-helm-charts/apigee-apim-operator-crds \
  --version 1.1.0 \
  --atomic
```
3. Instala el operador de Apigee para Kubernetes:
```
helm install apigee-apim-operator -n apim \
  oci://us-docker.pkg.dev/apigee-release/apigee-k8s-tooling-helm-charts/apigee-apim-operator-helm \
  --version 1.1.0 \
  --set serviceAccount=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com \
  --set apigeeOrg=$APIGEE_ORG \
  --set apigeeEnv=ENV_NAME \
  --set-file serviceAccountKeyFileContent=$PROJECT_ID-apigee-apim-gsa-key.json \
  --atomic
```
  Donde ENV_NAME es el nombre del entorno de Apigee Hybrid en el que quieres instalar el operador de Apigee para Kubernetes.
4. Confirma que la instalación se ha completado correctamente:
```
helm list -n apim
```
  La salida debería ser similar a la siguiente:
```
NAME  NAMESPACE  REVISION  UPDATED  STATUS  CHART  APP VERSION
apigee-apim-crds  apim  1  2025-09-01 00:17:03.399810627 +0000 UTC  deployed  apigee-apim-operator-crds-1.1.0  1.1.0
apigee-apim-operator  apim  1  2025-09-01 00:15:00.362829981 +0000 UTC  deployed  apigee-apim-operator-helm-1.1.0  1.1.0
```
5. Confirma que la cuenta de servicio de Kubernetes (KSA) se ha creado con la anotación necesaria:
```
kubectl describe serviceaccounts apim-ksa -n apim
```
  La salida debería ser similar a la siguiente:
```
Name:                apim-ksa
Namespace:           apim
...
Annotations:         iam.gke.io/gcp-service-account: apigee-apim-gsa@my-project-id.iam.gserviceaccount.com
```
6. Confirma que el operador de Apigee para Kubernetes está en funcionamiento en los pods del clúster:
```
kubectl get pods -n apim
```
  La salida debería ser similar a la siguiente:
```
NAME  READY  STATUS  RESTARTS  AGE
apigee-apim-operator-8559d4994b-h55fl   1/1     Running   0   8m34s
```
  Si el estado no es Running o READY no muestra 1/1, consulte Solucionar problemas del operador de Apigee para Kubernetes para solucionar problemas de instalación.
Crear un entorno de Apigee Hybrid

Para usar el operador de Apigee para Kubernetes en Apigee Hybrid, debes crear un entorno con una marca especial para la extensión de servicio.
1. Obtén un token para autenticarte en la API de Apigee.
  En la línea de comandos, obtén tus credenciales de autenticación gcloud, como se muestra en el siguiente ejemplo:
```
TOKEN=$(gcloud auth print-access-token)
```
  Para comprobar que se ha rellenado el token, usa echo, como se muestra en el siguiente ejemplo:
```
echo $TOKEN
```
  Debería mostrar tu token como una cadena codificada.
  
  Para obtener más información, consulta la descripción general de la herramienta de línea de comandos gcloud.
2. Crea el entorno con uno de los siguientes comandos:
  - Para las organizaciones con una suscripción del 2021:
```
curl -X POST "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments" -H \
  "Authorization: Bearer $TOKEN" -H "content-type:application/json" \
    -d '{
      "name": "ENV_NAME",
      "displayName": "ENV_DISPLAY_NAME",
      "state": "ACTIVE",
      "deploymentType": "PROXY",
      "apiProxyType": "PROGRAMMABLE",
      "properties": {
        "property": [
          {
            "name": "apigee-service-extension-enabled",
            "value": "true"
          }
        ]
      }
    }'
```
    En este comando, ENV_NAME es el nombre del entorno que quieres crear.
  - En el caso de las organizaciones con suscripción del 2024 y de pago por uso:
```
curl -i -X POST -H "Authorization: Bearer $TOKEN"  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments" -H "Content-Type:application/json" -d '{
  "name": "ENV_NAME",
  "displayName": "ENV_NAME",
  "state": "ACTIVE",
  "deploymentType": "PROXY",
  "apiProxyType": "PROGRAMMABLE",
  "type" : "ENV_TYPE",
  "properties": {
    "property": [
      {
        "name": "apigee-service-extension-enabled",
        "value": "true"
      }
    ]
  }
}'
```
    Donde:
    - ENV_NAME es el nombre del entorno que quieres crear.
    - ENV_TYPE es el tipo de entorno que quieres crear. Por ejemplo, INTERMEDIATE o COMPREHENSIVE.
  Comprueba que el entorno se haya creado correctamente:
```
curl -i -H "Authorization: Bearer $TOKEN" \
  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments"
```
  Consulta Crear un entorno en las instrucciones de instalación de Apigee Hybrid para obtener más información.
3. Crea un grupo del entorno con el siguiente comando:
```
curl -i -X POST -H "Authorization: Bearer $TOKEN"  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/envgroups" -H "Content-Type:application/json" -d '{
     "name": "'"$ENV_GROUP"'",
     "hostnames":["'"$DOMAIN"'"]
   }'
```
  Donde:
  - ENV_GROUP Obligatorio El nombre del entorno puede contener letras minúsculas, guiones y números, y debe empezar por una letra minúscula. Este nombre se usará como identificador y no se podrá cambiar después de la creación.
  - DOMAIN (Obligatorio) Es el nombre de host que usarán todos los proxies implementados en entornos de este grupo. Debe ser un dominio que gestiones. La dirección puede ser el propio dominio, como example.com, o puede incluir un subdominio, como my-proxies.example.com. Si no tienes un dominio gestionado, puedes introducir un marcador de posición por ahora. Puedes cambiar la dirección del dominio más adelante.
  Para obtener más información, consulta el artículo Crear un grupo de entornos de las instrucciones de instalación de Apigee Hybrid.
4. Vincula el entorno al grupo de entornos que acabas de crear con el siguiente comando:
```
curl -i -X POST -H "Authorization: Bearer $TOKEN"  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/envgroups/$ENV_GROUP/attachments" -H "Content-Type:application/json" -d '{
     "environment": "'"$ENV_NAME"'",
   }'
```
Instalar el entorno de Apigee Hybrid con Helm

El procedimiento para instalar el nuevo entorno en el clúster de Apigee Hybrid es similar al que seguiste para instalar otros entornos en tu clúster. Esto es necesario para añadir nuevos detalles de entorno y de grupo de entornos a nuestro clúster de Kubernetes en el que se instaló Apigee Hybrid.
1. Genera el certificado TLS para el dominio del grupo de entornos con el siguiente comando:
```
openssl req -nodes -new -x509 -keyout $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.key -out $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.pem -subj "/CN=$DOMAIN" -addext "subjectAltName = DNS:$DOMAIN" -days 3650
```
  Donde:
  - APIGEE_HELM_CHARTS_HOME (Obligatorio) Directorio en el que descargaste los gráficos de Helm de Apigee durante la instalación de Apigee Hybrid.
2. Codifica en Base64 el certificado público TLS con el siguiente comando:
```
cat $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.pem | base64 -w0 > $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.pem.base64
```
3. Actualiza el archivo overrides.yaml con la siguiente entrada en envs
```
- name: ENV_NAME
  serviceAccountPaths:
    # Provide the path relative to the apigee-env chart directory.
    synchronizer: SYNCHRONIZER_SERVICE_ACCOUNT_FILEPATH
    # For example: "PROJECT_ID-apigee-synchronizer.json"
    runtime: RUNTIME_SERVICE_ACCOUNT_FILEPATH
    # For example: "PROJECT_ID-apigee-runtime.json"
    udca: UDCA_SERVICE_ACCOUNT_FILEPATH
    # For example: "PROJECT_ID-apigee-udca.json"
```
  Donde *_SERVICE_ACCOUNT_FILEPATH (obligatorio) es el archivo de clave JSON de la cuenta de servicio que has usado durante la instalación de Apigee Hybrid. Consulta Crear las anulaciones en las instrucciones de instalación de Apigee Hybrid para obtener más información.
4. Añade la siguiente entrada al archivo overrides.yaml en virtualhosts
```
- name: 
  selector:
    app: apigee-ingressgateway
    ingress_name: INGRESS_NAME
  sslCertPath: certs/keystore_$ENV_GROUP.pem
  sslKeyPath: certs/keystore_$ENV_GROUP.key
```
  INGRESS_NAME (obligatorio) es el nombre de la pasarela de entrada de Apigee de tu implementación. Consulta este artículo para obtener más información.
5. Instalar el entorno y el grupo de entornos
  1. Instala el entorno.
    
    Debes instalar un entorno cada vez. Especifica el entorno con --set env=ENV_NAME. Si has definido la variable de entorno $ENV_NAME en tu shell, puedes usarla en los siguientes comandos:
    
    Prueba de funcionamiento:
```
helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set env=$ENV_NAME \
  -f overrides.yaml \
  --dry-run=server
```
    Instala el gráfico:
```
helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set env=$ENV_NAME \
  -f overrides.yaml
```
    Para comprobar que está en funcionamiento, consulta el estado del entorno correspondiente:
```
kubectl -n APIGEE_NAMESPACE get apigeeenv
```
```
NAME                    STATE       AGE   GATEWAYTYPE
apigee-org1-dev-1       running     2d
```
  2. Instala los grupos de entornos (virtualhosts).
    1. Debes instalar un grupo de entornos (virtualhost) a la vez. Especifica el grupo de entornos con --set envgroup=ENV_GROUP. Si has definido la variable de entorno $ENV_GROUP en tu shell, puedes usarla en los siguientes comandos. Repite los siguientes comandos para cada grupo de entorno mencionado en tu archivo overrides.yaml:
      Prueba de funcionamiento:
      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \ --install \ --namespace APIGEE_NAMESPACE \ --atomic \ --set envgroup=$ENV_GROUP \ -f overrides.yaml \ --dry-run=server
      Instala el gráfico:
      helm upgrade $ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \ --install \ --namespace APIGEE_NAMESPACE \ --atomic \ --set envgroup=$ENV_GROUP \ -f overrides.yaml
      Nota: ENV_GROUP debe ser único en el espacio de nombres apigee. Por ejemplo, si tiene un prod env y un envgroup, debe asignar el nombre prod-envgroup. El nombre del grupo de entorno posterior debe seguir siendo prod.
  Tu organización de Apigee Hybrid ya está lista con el nuevo entorno para probar la extensión de servicio.
  
  Sigue los procedimientos que se indican en Crear un APIMExtensionPolicy para crear una excepción a la política.

Instalar el operador de Apigee para Kubernetes en Apigee Hybrid Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Antes de empezar

Roles obligatorios

Tareas de configuración obligatorias

Verificar la configuración de la pasarela de Istio (opcional)

Instalar el operador de Apigee para Kubernetes

Instalar y configurar el operador de Apigee para Kubernetes

Establece variables de entorno:

Crear y configurar la cuenta de servicio de APIM

Instalar el operador de Apigee para Kubernetes

Crear un entorno de Apigee Hybrid

Instalar el entorno de Apigee Hybrid con Helm

Instalar el operador de Apigee para Kubernetes en Apigee Hybrid