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

Instala Apigee Operator para Kubernetes para 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 los beneficios de usar Apigee Operator para Kubernetes, consulta la descripción general de Apigee Operator para Kubernetes.

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

Antes de comenzar

Antes de comenzar, asegúrate de tener lo siguiente:

Roles requeridos

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

Crear y administrar cuentas de servicio: Administrador de cuentas de servicio (roles/iam.serviceAccountAdmin)
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 a través de roles personalizados o cualquier otro rol predefinido.

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 posterior. Consulta Panorama general para obtener instrucciones para 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 la comunicación con el proyecto Google Cloud que contiene tu instancia de Apigee Hybrid.

Instala la puerta de enlace de Istio en tu clúster de K8s:

Para los clústeres en GKE, haz lo siguiente:

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

Para clústeres en 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

Implementa la puerta de enlace de Istio en tu clúster de Kubernetes.

Crea un archivo llamado gateway.yaml con el siguiente contenido para implementar Istio Gateway:

#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
```

Verifica la configuración de la puerta de enlace de Istio (opcional)

Para los fines de esta guía, te recomendamos que implementes una aplicación de muestra de httpbin en el espacio de nombres predeterminado para probar la puerta de enlace que implementaste.

Implementa una aplicación de backend en tu clúster de Kubernetes para probar la puerta de enlace.
1. Crea un archivo nuevo 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 como un archivo llamado target.yaml. Luego, aplica la configuración a tu clúster con el siguiente comando:
```
kubectl apply -f target.yaml
```
2. Implementa el recurso de 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 puerta de enlace y una HTTPRoute externas. Para ello, sigue los pasos que se indican en Crea una HTTPRoute.
  
  Para obtener más información sobre el recurso HTTPRoute, consulta Implementa el recurso HTTPRoute (para las Gateways internas) o Crea un recurso HTTPRoute (para las Gateways externas).
  1. Crea una HTTPRoute siguiendo las instrucciones en Crea la 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 GKE Gateway para confirmar que funciona según lo esperado.
  Nota: Los cambios aplicados pueden tardar hasta cinco minutos en propagarse. Si no ves el resultado esperado para los pasos de esta sección, espera unos minutos y vuelve a intentarlo.
  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
istio-gateway   istio   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 istio-gateway
```
    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 Rutas adjuntas 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: example.httpbin.com"
```
    Donde 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.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"
}
```
Instala el operador de Apigee para Kubernetes

En este procedimiento, se describen los pasos necesarios para instalar y configurar el operador de Apigee para Kubernetes.
Instala y configura 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:
Configure las variables de entorno

En el proyecto Google Cloud que contiene tu instancia de Apigee, usa el siguiente comando para configurar las variables de entorno:
```
export PROJECT_ID=PROJECT_ID
export APIGEE_ORG=APIGEE_ORG
```
Aquí:
- 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 estén configuradas correctamente con el siguiente comando:
```
echo $PROJECT_ID $APIGEE_ORG
```
Crea y configura la cuenta de servicio de APIM

Crea una cuenta de servicio para conectarte al plano de configuración de Apigee Hybrid.
1. Crea la cuenta de servicio apigee-apim-gsa para conectarte a los servicios de Google Cloud
2. Otorga el rol de administrador de Apigee a la cuenta de servicio que creaste con el siguiente comando. Este rol es obligatorio para crear y administrar 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 claves JSON correspondiente para la cuenta de servicio.
  1. Crea y descarga el archivo de claves $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. Verifica que el archivo se haya descargado correctamente:
```
ls $PROJECT_ID-apigee-apim-gsa.json
        
```
Instala el operador de Apigee para Kubernetes

Instala las definiciones de recursos personalizados (CRD) de Kubernetes y el operador de Apigee para Kubernetes:
1. Crea un espacio de nombres para el operador de Apigee para Kubernetes
```
kubectl create namespace apim
```
2. Instala las definiciones de recursos personalizados (CRD) 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
```
  Aquí, ENV_NAME es el nombre del entorno de Apigee Hybrid en el que deseas instalar Apigee Operator para Kubernetes.
4. Confirma que la instalación se haya completado correctamente:
```
helm list -n apim
```
  El resultado debería ser similar al 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 haya creado con la anotación requerida:
```
kubectl describe serviceaccounts apim-ksa -n apim
```
  El resultado debería ser similar al 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
```
  El resultado debería ser similar al 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, consulta Soluciona problemas del operador de Apigee para Kubernetes para solucionar problemas de instalación.
Crea 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 de gcloud, como se muestra en el siguiente ejemplo:
```
TOKEN=$(gcloud auth print-access-token)
```
  Para verificar que tu token se haya propagado, usa echo, como se muestra en el siguiente ejemplo:
```
echo $TOKEN
```
  Se debería mostrar tu token como una string codificada.
  
  Para obtener más información, consulta la descripción general de la herramienta de línea de comandos de gcloud.
2. Crea el entorno con uno de los siguientes comandos:
  - Para las organizaciones de suscripción de 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"
          }
        ]
      }
    }'
```
    Aquí, ENV_NAME es el nombre del entorno que deseas crear.
  - Para las organizaciones de suscripción 2024 y de pago por uso, haz lo siguiente:
```
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"
      }
    ]
  }
}'
```
    Aquí:
    - ENV_NAME es el nombre del entorno que deseas crear.
    - ENV_TYPE es el tipo de entorno que deseas 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 Crea un entorno en las instrucciones de instalación de Apigee Hybrid para obtener más información.
3. Crea un grupo de entornos 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"'"]
   }'
```
  Aquí:
  - ENV_GROUP (obligatorio): El nombre del entorno puede contener letras en minúscula, guiones y números, y debe comenzar con una letra en minúscula. Este nombre se usará como identificador y no se podrá cambiar después de la creación.
  - DOMAIN (Obligatorio) Este es el nombre de host que usarán todos los proxies implementados en entornos dentro de este grupo. Este debería ser un dominio que administres. La dirección puede ser el dominio en sí, como example.com, o puede incluir un subdominio, como my-proxies.example.com. Si no tienes un dominio administrado, puedes ingresar un marcador de posición por ahora. Puedes cambiar la dirección del dominio más adelante.
  Consulta Crea un grupo de entornos en las instrucciones de instalación de Apigee Hybrid para obtener más información.
4. Conecta 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"'",
   }'
```
Instala 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 usaste para instalar otros entornos en tu clúster. Esto es necesario para agregar detalles nuevos del entorno y del 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
```
  Aquí:
  - APIGEE_HELM_CHARTS_HOME (Obligatorio) Directorio en el que descargaste los gráficos de Helm para Apigee durante la instalación de Apigee Hybrid.
2. Codifica el certificado público de TLS en Base64 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"
```
  Aquí, *_SERVICE_ACCOUNT_FILEPATH (obligatorio) es el archivo de claves JSON de la cuenta de servicio que usaste durante la instalación de Apigee Hybrid. Para obtener más información, consulta Crea las anulaciones en las instrucciones de instalación de Apigee Hybrid.
4. Agrega la siguiente entrada en el 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
```
  Aquí, INGRESS_NAME (obligatorio) es el nombre de la puerta de enlace de entrada de Apigee para tu implementación. Consulta aquí para obtener más información.
5. Instala el entorno y el grupo de entornos.
  1. Instala el entorno.
    
    Debes instalar un entorno a la vez. Especifica el entorno con --set env=ENV_NAME. Si configuraste la variable de entorno $ENV_NAME en tu shell, puedes usarla en los siguientes comandos:
    
    Prueba de validación:
```
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 verificar que esté en funcionamiento, comprueba 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 configuraste la variable de entorno $ENV_GROUP en tu shell, puedes usarla en los siguientes comandos. Repite los siguientes comandos para cada grupo de entornos mencionado en tu archivo overrides.yaml:
      Prueba de validación:
      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 tienes un entorno y un grupo de entornos prod, debes establecer este nombre en prod-envgroup. El nombre del grupo de entornos posterior debe ser prod.
  Tu organización de Apigee Hybrid ahora está lista con el nuevo entorno para probar la extensión de servicio.
  
  Continúa con los procedimientos en Crea un APIMExtensionPolicy para crear una política de extensión.

Instala Apigee Operator para Kubernetes para Apigee Hybrid Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Antes de comenzar

Roles requeridos

Tareas de configuración obligatorias

Verifica la configuración de la puerta de enlace de Istio (opcional)

Instala el operador de Apigee para Kubernetes

Instala y configura el operador de Apigee para Kubernetes

Configure las variables de entorno

Crea y configura la cuenta de servicio de APIM

Instala el operador de Apigee para Kubernetes

Crea un entorno de Apigee Hybrid

Instala el entorno de Apigee Hybrid con Helm

Instala Apigee Operator para Kubernetes para Apigee Hybrid