Instala el operador de Apigee para Kubernetes

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 para instalar y configurar el operador de Apigee para Kubernetes. Para obtener más información sobre los beneficios de usar el operador de Apigee para Kubernetes, consulta Descripción general del operador de Apigee para Kubernetes.

Antes de comenzar

Antes de instalar el operador de Apigee para Kubernetes, asegúrate de tener los roles y permisos necesarios para completar los pasos y de haber completado las tareas de requisitos previos que se describen en Operador de Apigee para Kubernetes: Antes de comenzar.

Roles obligatorios

Para obtener los permisos que necesitas para instalar el operador de Apigee para Kubernetes, pídele a tu administrador que te otorgue los siguientes roles de IAM en la organización:

• Crear y administrar el clúster de 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 de servicio: Administrador de extensiones de 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 a través de roles personalizados o cualquier otro rol predefinido.

Instala y configura el operador de Apigee para Kubernetes

En las siguientes secciones, se describen los pasos para instalar y configurar el operador de Apigee para Kubernetes:

1. Configura las variables de entorno.
2. Habilita las API necesarias.
3. Recupera y configura las credenciales.
4. Crea una identidad para cargas de trabajo.
5. Instala el operador de Apigee para Kubernetes.
6. Crea un entorno de Apigee.
7. Verifica la configuración de la puerta de enlace de GKE.

Configura las variables de entorno

En el Google Cloud proyecto que contiene tu instancia de Apigee, usa el siguiente comando para establecer las variables de entorno:

export PROJECT_ID=PROJECT_ID
export CLUSTER_NAME=CLUSTER_NAME
export REGION=REGION
export APIGEE_ORG=APIGEE_ORG

Aquí:

• PROJECT_ID es el ID del proyecto con tu instancia de Apigee.
• CLUSTER_NAME es el nombre del clúster de GKE.
• REGION es la región de tu clúster de GKE.
• APIGEE_ORG se establece en el mismo valor que PROJECT_ID.

Para confirmar que las variables de entorno estén configuradas correctamente, ejecuta el siguiente comando:

echo $PROJECT_ID $CLUSTER_NAME $REGION $APIGEE_ORG

Habilita las API obligatorias

El operador de Apigee para Kubernetes requiere acceso a las siguientes APIs:

Nombre	Título
apigee.googleapis.com	API de Apigee
compute.googleapis.com	API de Compute Engine
networkservices.googleapis.com	API de Network Services
container.googleapis.com	API de Kubernetes Engine

Usa el siguiente comando para confirmar que las APIs obligatorias estén habilitadas:

gcloud services list --project=$PROJECT_ID

Si no ves las APIs obligatorias en el resultado del comando, habilítalas:

gcloud services enable apigee.googleapis.com --project=$PROJECT_ID
gcloud services enable compute.googleapis.com --project=$PROJECT_ID
gcloud services enable networkservices.googleapis.com --project=$PROJECT_ID
gcloud services enable container.googleapis.com --project=$PROJECT_ID

Recupera y configura las credenciales

Recupera las credenciales del clúster y crea una cuenta de servicio para conectarte a los Google Cloud servicios:

1. Obtén las credenciales del clúster con el siguiente comando:

   gcloud container clusters get-credentials $CLUSTER_NAME --location=$REGION --project=$PROJECT_ID

   Estas credenciales se comunican con el clúster de GKE creado en los pasos de requisitos previos.

2. Configura las credenciales de la cuenta de servicio para conectarte a los Google Cloud servicios:

   gcloud iam service-accounts create apigee-apim-gsa

3. Otorga los roles y permisos necesarios a la cuenta de servicio que creaste con los siguientes comandos:
   • Rol de administrador de Apigee: Es necesario 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"

   • Rol de administrador de extensiones de servicio: Es necesario para crear y administrar extensiones de servicio.

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/networkservices.serviceExtensionsAdmin"

   • Rol de administrador de redes: Es necesario para administrar el acceso a Apigee mediante extensiones de servicio.

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/compute.networkAdmin"

   • Rol de administrador de balanceador de cargas: Es necesario para administrar el acceso entre los grupos de extremos de red (NEG) y los servicios de backend.

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/compute.loadBalancerAdmin"

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/iam.workloadIdentityUser"

Crea una identidad para cargas de trabajo

La instalación de helm del operador de Apigee para Kubernetes en el siguiente paso crea una cuenta de servicio de Kubernetes (KSA) obligatoria llamada apim-ksa en el espacio de nombres apim. Cuando se crea, la KSA contiene la anotación necesaria para asociarse con una identidad para cargas de trabajo que usa el operador de Apigee para Kubernetes para acceder a los recursos obligatorios de Apigee y Service Networking.

Para crear la identidad para cargas de trabajo, usa el siguiente comando:

gcloud iam service-accounts add-iam-policy-binding apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com --role roles/iam.workloadIdentityUser --member "serviceAccount:$PROJECT_ID.svc.id.goog[apim/apim-ksa]"

Este comando vincula la KSA con la Google cuenta de servicio que creaste en Recupera y configura las credenciales y asigna el rol workloadIdentityUser.

Es posible que los cambios en la identidad para cargas de trabajo tarden unos minutos en propagarse por todo el sistema (posiblemente 7 minutos o más). Verificarás esta identidad en un paso posterior después de instalar el operador.

Instala las Definiciones de recursos personalizadas (CRD) y el operador de Apigee para Kubernetes

Instala las Definiciones de recursos personalizadas (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 ns apim

2. Instala las 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.1 \
     --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.1 \
     --set projectId=$PROJECT_ID \
     --set serviceAccount=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com \
     --set apigeeOrg=$PROJECT_ID \
     --set generateEnv=ENV_GENERATION_MODE \
     --atomic

   Reemplaza ENV_GENERATION_MODE por TRUE si deseas que el operador cree un entorno de Apigee nuevo cuando se instale el operador de Apigee para Kubernetes. Establece ENV_GENERATION_MODE en FALSE si deseas crear el entorno de forma manual después de instalar el operador. Consulta Crea un entorno de Apigee para obtener más información.

4. Confirma que la instalación se completó 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-02-01 00:17:03.399810627 +0000 UTC deployed  apigee-apim-operator-crds-1.1.1 1.1.1
   apigee-apim-operator  apim      1         2025-02-01 00:15:00.362829981 +0000 UTC deployed  apigee-apim-operator-helm-1.1.1 1.1.1   

5. Confirma que la KSA se creó con la anotación obligatoria:

   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: [e-mail]

6. Confirma que el operador de APIM 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 STATUS no es Running o READY no muestra 1/1, consulta Soluciona problemas del operador de Apigee para Kubernetes para solucionar problemas de instalación.

7. Para confirmar que la identidad para cargas de trabajo esté configurada correctamente, usa los siguientes comandos:

   gcloud config set project $PROJECT_ID

   kubectl run --rm -it --image google/cloud-sdk:slim \
     --namespace apim workload-identity-test \
     --overrides='{ "spec": { "serviceAccountName": "apim-ksa" } }'  \
     -- gcloud auth list

   El resultado debería ser similar al siguiente:

   Credentialed Accounts
     ACTIVE  ACCOUNT
     *       GSA@$PROJECT_ID.iam.gserviceaccount.com

Crea un entorno de Apigee

Si instalaste el operador de Apigee para Kubernetes con generateEnv=TRUE en el paso anterior, el operador crea un entorno de Apigee nuevo cuando se crea y aplica la política de extensión de APIM. El nombre del entorno nuevo tiene el prefijo: apim-enabled-dep-env.

Si instalaste el operador de Apigee para Kubernetes con generateEnv=FALSE, debes crear un entorno de Apigee nuevo:

1. Establece el TOKEN necesario para el comando curl:

   export TOKEN=$(gcloud auth print-access-token)

2. Crea el entorno con uno de los siguientes comandos:
   • Para organizaciones de suscripción 2021 y 2024:

     curl -i -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_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 se creará.

   • Para organizaciones 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" : "COMPREHENSIVE",
       "properties": {
         "property": [
           {
             "name": "apigee-service-extension-enabled",
             "value": "true"
           }
         ]
       }
     }'

     Aquí:

     • ENV_NAME es el nombre del entorno que se creará.
     Nota: El entorno creado en este paso o creado por el operador de Apigee para Kubernetes es un entorno intermedio o integral para admitir el uso de proxies extensibles. Esta función no se puede usar con entornos básicos.

   Para verificar que el entorno se haya creado correctamente:

   curl -i -H "Authorization: Bearer $TOKEN" \
     "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments"

3. Adjunta el entorno a tu instancia de Apigee:

   curl -i -X POST -H "Authorization: Bearer $TOKEN" \
     "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/instances/INSTANCE_NAME/attachments" \
     -H "Content-Type:application/json" -d '{"environment": "ENV_NAME"}'

   Aquí:

   • INSTANCE_NAME es el nombre de tu instancia de Apigee.
   • ENV_NAME es el nombre del entorno que creaste en el paso anterior.

   Para verificar el estado de la operación de adjuntos del entorno:

   curl -X GET -H "Authorization: Bearer $TOKEN" \
     "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/operations/OPERATION_ID"

   Aquí, OPERATION_ID es el ID de la operación de adjuntos del entorno.

Solucionar problemas

Si tienes problemas para instalar el operador de Apigee para Kubernetes, consulta Soluciona problemas del operador de Apigee para Kubernetes para obtener soluciones a errores comunes.

¿Qué sigue?

Crea una extensión de servicio de tráfico con APIMExtensionPolicy o ApigeeBackendService:

• Crea un APIMExtensionPolicy
• Crea un ApigeeBackendService