Instala y administra Apigee Hybrid con gráficos de Helm

Vista previa — Installing Apigee hybrid with Helm charts

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

Nota: Este documento de vista previa se aplica a Apigee Hybrid v1.10.x.

En este documento, se explica el proceso paso a paso para instalar Apigee Hybrid v1.10 con gráficos de Helm.

Versión

Los gráficos de Helm de Apigee Hybrid están destinados a Apigee Hybrid v1.10.x. Consulta el historial de versiones de Apigee Hybrid para obtener la lista de versiones híbridas.

Requisitos previos

• Apigee Hybrid 1.10.4
• Helm v3.10+
• Acceso al repositorio de gráficos de Helm de Apigee Hybrid en:
  oci://us-docker.pkg.dev/apigee-release/apigee-hybrid-helm-charts
• CLI de gcloud
• Crea y administra proyectos
• Un clúster de Kubernetes para la instalación de Apigee Hybrid. Consulta:
  • Plataforma y versión compatibles de Kubernetes
  • Opciones de configuración mínimas de los clústeres

Alcance

• Esta versión solo es compatible con la versión 1.10.4 de Apigee Hybrid.
• Esta versión es compatible con lo siguiente:
  • Instalaciones nuevas de Apigee Hybrid.
  • Las instalaciones existentes de Apigee Hybrid que se hayan actualizado a la versión 1.10.4 y se hayan migrado a la administración de Helm con la herramienta de migración de Helm de Apigee Hybrid.
• Esta versión es compatible con lo siguiente:
  • Instalación básica de Apigee Hybrid
  • Copia de seguridad y restablecimiento de Cassandra
  • Configuración multirregional

Nota: Para administrar los clústeres de Apigee Hybrid existentes que se iniciaron con apigeectl, consulta Herramienta de migración de Helm de Apigee Hybrid.

Plataformas y versiones de Kubernetes compatibles

Plataforma	Versiones
GKE	1.24, 1.25, 1.26
AKS	1.24, 1.25, 1.26
EKS	1.24, 1.25, 1.26
OpenShift	4.11, 4.12

Limitaciones

• Los gráficos de Helm no admiten por completo las CRD; por lo tanto, usaremos el comando kubectl -k para instalarlos y actualizarlos. Nuestro objetivo es seguir las prácticas recomendadas de la comunidad y Google en relación con la administración de Kubernetes. Las implementaciones de CRD con Helm aún no alcanzaron un estado de la comunidad en el que observamos una amplia asistencia o solicitudes para ese modelo. Por lo tanto, la administración de las CRD de Apigee debe realizarse con kubectl, como se menciona en este documento.
• En apigeectl, usamos archivos en overrides.yaml para cuentas de servicio y certificados; sin embargo, Helm no admite archivos de referencia fuera del directorio del gráfico. Elige una de las siguientes opciones para la cuenta de servicio y los archivos de certificación:
  • Coloca copias de los archivos relevantes dentro de cada directorio del gráfico
  • Crea vínculos simbólicos dentro de cada directorio del gráfico para cada archivo o una carpeta. Helm seguirá los vínculos simbólicos fuera del directorio del gráfico, pero mostrará una advertencia como la siguiente:
    apigee-operator/gsa -> ../gsa
  • Usa los secretos sde Kubernetes Por ejemplo, para las cuentas de servicio:

    kubectl create secret generic SECRET_NAME \
      --from-file="client_secret.json=CLOUD_IAM_FILE_NAME.json" \
      -n apigee
    

    Reemplaza lo siguiente:
    • SECRET_NAME por el nombre del Secret de Kubernetes que creaste.
    • CLOUD_IAM_FILE_NAME.json por el nombre del archivo JSON descargado.

Plataformas y versiones compatibles de Kubernetes

Para obtener una lista de las plataformas compatibles, consulta la columna v1.10 en la tabla de plataformas compatibles con Apigee Hybrid.

Permisos necesarios

En esta tabla, se enumeran los recursos y permisos necesarios para Kubernetes y Apigee.

Para filtrar esta tabla, realiza una o más de las siguientes acciones: selecciona una categoría, escribe un término de búsqueda o haz clic en el encabezado de una columna para ordenar.

Selecciona una categoría Datastore Entorno Administrador de Ingress Operador Unidad organizativa Redis Telemetría Host virtual

Categoría	Recurso	Tipo de recurso	Permisos de RBAC de Kubernetes
Datastore	apigeedatastores.apigee.cloud.google.com	Apigee	create delete patch update
Datastore	certificates.cert-manager.io	Kubernetes	create delete patch update
Datastore	cronjobs.batch	Kubernetes	create delete patch update
Datastore	jobs.batch	Kubernetes	create delete patch update
Datastore	secrets	Kubernetes	create delete patch update
Entorno	apigeeenvironments.apigee.cloud.google.com	Apigee	create delete patch update
Entorno	secrets	Kubernetes	create delete patch update
Entorno	serviceaccounts	Kubernetes	create delete patch update
Administrador de Ingress	certificates.cert-manager.io	Kubernetes	create delete patch update
Administrador de Ingress	configmaps	Kubernetes	create delete patch update
Administrador de Ingress	deployments.apps	Kubernetes	create delete patch update
Administrador de Ingress	horizontalpodautoscalers.autoscaling	Kubernetes	create delete patch update
Administrador de Ingress	issuers.cert-manager.io	Kubernetes	create delete patch update
Administrador de Ingress	serviceaccounts	Kubernetes	create delete patch update
Administrador de Ingress	services	Kubernetes	create delete patch update
Operador	apigeedatastores.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operador	apigeedatastores.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operador	apigeedatastores.apigee.cloud.google.com/status	Apigee	get patch update
Operador	apigeedeployments.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operador	apigeedeployments.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operador	apigeedeployments.apigee.cloud.google.com/status	Apigee	get patch update
Operador	apigeeenvironments.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operador	apigeeenvironments.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operador	apigeeenvironments.apigee.cloud.google.com/status	Apigee	get patch update
Operador	apigeeissues.apigee.cloud.google.com	Apigee	create delete get list watch
Operador	apigeeorganizations.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operador	apigeeorganizations.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operador	apigeeorganizations.apigee.cloud.google.com/status	Apigee	get patch update
Operador	apigeeredis.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operador	apigeeredis.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operador	apigeeredis.apigee.cloud.google.com/status	Apigee	get patch update
Operador	apigeerouteconfigs.apigee.cloud.google.com	Apigee	get list
Operador	apigeeroutes.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operador	apigeeroutes.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operador	apigeeroutes.apigee.cloud.google.com/status	Apigee	get patch update
Operador	apigeetelemetries.apigee.cloud.google.com	Apigee	create delete get list patch update watch
Operador	apigeetelemetries.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operador	apigeetelemetries.apigee.cloud.google.com/status	Apigee	get list patch update
Operador	cassandradatareplications.apigee.cloud.google.com	Apigee	get list patch update watch
Operador	cassandradatareplications.apigee.cloud.google.com/finalizers	Apigee	get patch update
Operador	cassandradatareplications.apigee.cloud.google.com/status	Apigee	get patch update
Operador	*.networking.x.k8s.io	Kubernetes	get list watch
Operador	apiservices.apiregistration.k8s.io	Kubernetes	create delete get list patch update watch
Operador	certificates.cert-manager.io	Kubernetes	create delete get list patch update watch
Operador	certificates.cert-manager.io/finalizers	Kubernetes	create delete get list patch update watch
Operador	certificatesigningrequests.certificates.k8s.io	Kubernetes	create delete get update watch
Operador	certificatesigningrequests.certificates.k8s.io/approval	Kubernetes	create delete get update watch
Operador	certificatesigningrequests.certificates.k8s.io/status	Kubernetes	create delete get update watch
Operador	clusterissuers.cert-manager.io	Kubernetes	create get watch
Operador	clusterrolebindings.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Operador	clusterroles.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Operador	configmaps	Kubernetes	create delete get list patch update watch
Operador	configmaps/status	Kubernetes	get patch update
Operador	cronjobs.batch	Kubernetes	create delete get list patch update watch
Operador	customresourcedefinitions.apiextensions.k8s.io	Kubernetes	get list watch
Operador	daemonsets.apps	Kubernetes	create delete get list patch update watch
Operador	deployments.apps	Kubernetes	get list watch
Operador	deployments.extensions	Kubernetes	get list watch
Operador	destinationrules.networking.istio.io	Kubernetes	create delete get list patch update watch
Operador	endpoints	Kubernetes	get list watch
Operador	endpointslices.discovery.k8s.io	Kubernetes	get list watch
Operador	events	Kubernetes	create delete get list patch update watch
Operador	gateways.networking.istio.io	Kubernetes	create delete get list patch update watch
Operador	horizontalpodautoscalers.autoscaling	Kubernetes	create delete get list patch update watch
Operador	ingressclasses.networking.k8s.io	Kubernetes	get list watch
Operador	ingresses.networking.k8s.io/status	Kubernetes	all verbs
Operador	issuers.cert-manager.io	Kubernetes	create delete get list patch update watch
Operador	jobs.batch	Kubernetes	create delete get list patch update watch
Operador	leases.coordination.k8s.io	Kubernetes	create get list update
Operador	namespaces	Kubernetes	get list watch
Operador	nodes	Kubernetes	get list watch
Operador	peerauthentications.security.istio.io	Kubernetes	create delete get list patch update watch
Operador	persistentvolumeclaims	Kubernetes	create delete get list patch update watch
Operador	persistentvolumes	Kubernetes	get list watch
Operador	poddisruptionbudgets.policy	Kubernetes	create delete get list patch update watch
Operador	pods	Kubernetes	create delete get list patch update watch
Operador	pods/exec	Kubernetes	create
Operador	replicasets.apps	Kubernetes	create delete get list patch update watch
Operador	replicasets.extensions	Kubernetes	get list watch
Operador	resourcequotas	Kubernetes	create delete get list patch update watch
Operador	rolebindings.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Operador	roles.rbac.authorization.k8s.io	Kubernetes	create delete get list patch update watch
Operador	secrets	Kubernetes	batch create delete get list patch update watch
Operador	securitycontextconstraints.security.openshift.io	Kubernetes	create get list
Operador	serviceaccounts	Kubernetes	create delete get list patch update watch
Operador	services	Kubernetes	batch create delete get list patch update watch
Operador	signers.certificates.k8s.io	Kubernetes	approve
Operador	statefulsets.apps	Kubernetes	create delete get list patch update watch
Operador	subjectaccessreviews.authorization.k8s.io	Kubernetes	create get list
Operador	tokenreviews.authentication.k8s.io	Kubernetes	create
Operador	virtualservices.networking.istio.io	Kubernetes	create delete get list patch update watch
Unidad organizativa	apigeeorganizations.apigee.cloud.google.com	Apigee	create delete patch update
Unidad organizativa	secrets	Kubernetes	create delete patch update
Unidad organizativa	serviceaccounts	Kubernetes	create delete patch update
Redis	apigeeredis.apigee.cloud.google.com	Apigee	create delete patch update
Redis	secrets	Kubernetes	create delete patch update
Telemetría	apigeetelemetry.apigee.cloud.google.com	Apigee	create delete patch update
Telemetría	secrets	Kubernetes	create delete patch update
Telemetría	serviceaccounts	Kubernetes	create delete patch update
Host virtual	apigeerouteconfigs.apigee.cloud.google.com	Apigee	create delete patch update
Host virtual	secrets	Kubernetes	create delete patch update

También consulte lo siguiente:

• Usa la autorización de RBAC
• Determina el verbo de solicitud

Prepararse para la instalación

Los gráficos de Apigee Hybrid se alojan en Google Artifact Registry:

oci://us-docker.pkg.dev/apigee-release/apigee-hybrid-helm-charts

Extrae gráficos de Helm para Apigee

Con el comando pull, copia todos los gráficos de Helm de Apigee Hybrid en tu almacenamiento local con el siguiente comando:

export CHART_REPO=oci://us-docker.pkg.dev/apigee-release/apigee-hybrid-helm-charts
export CHART_VERSION=1.10.4
helm pull $CHART_REPO/apigee-operator --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-datastore --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-env --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-ingress-manager --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-org --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-redis --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-telemetry --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-virtualhost --version $CHART_VERSION --untar

Instala Apigee Hybrid

Descripción general de la secuencia de instalación

La instalación de los componentes se realiza de izquierda a derecha en secuencia, como se muestra en la siguiente figura. Los componentes que se apilan verticalmente en la figura se pueden instalar juntos y en cualquier orden. Una vez que hayas instalado cualquier componente, puedes actualizarlo de forma individual y en cualquier momento, por ejemplo, réplica, memoria, CPU, etcétera.

Prepárate para instalar Apigee Hybrid con gráficos de Helm

1. Crea el espacio de nombres que se usará para los recursos apigee. Este debe coincidir con el campo del espacio de nombres en el archivo overrides.yaml. Si no está presente en overrides.yaml, el valor predeterminado es apigee.

   1. Verifica si el espacio de nombres ya existe:

      kubectl get namespace apigee

      Si el espacio de nombres existe, el resultado incluye lo siguiente:

        NAME     STATUS   AGE
        apigee   Active   1d
      

   2. Si el espacio de nombres aún no existe, créalo:

      kubectl create namespace apigee

2. Crea las cuentas de servicio y asígnales los roles de IAM adecuados. Apigee Hybrid usa las siguientes cuentas de servicio:

   Cuenta de servicio	Roles de IAM
   apigee-cassandra	Administrador de objetos de Storage
   apigee-logger	Escritor de registros
   apigee-mart	Agente de Apigee Connect
   apigee-metrics	Escritor de métricas de Monitoring
   apigee-runtime	No se requiere una función
   apigee-synchronizer	Administrador de Apigee Synchronizer
   apigee-udca	Agente de Apigee Analytics
   apigee-watcher	Agente del entorno de ejecución de Apigee

   Apigee proporciona una herramienta, create-service-account, en el directorio apigee-operator/etc/tools:

   APIGEE_HELM_CHARTS_HOME/
   └── apigee-operator/
       └── etc/
           └── tools/
               └── create-service-account
   

   Esta herramienta crea las cuentas de servicio, asigna los roles de IAM a cada cuenta y descarga los archivos de certificado en formato JSON para cada cuenta.

   1. Crea el directorio en el que deseas descargar los archivos de certificación de la cuenta de servicio. Especificarás esto en el siguiente comando en lugar de SERVICE_ACCOUNTS_PATH.
   2. Puedes crear todas las cuentas de servicio con un solo comando a través de las siguientes opciones:

      APIGEE_HELM_CHARTS_HOME/apigee-operator/etc/tools/create-service-account --env prod --dir SERVICE_ACCOUNTS_PATH
      

   3. Enumera los nombres de las cuentas de servicio para el archivo de anulación:

      ls service-accounts
      

      my_project-apigee-cassandra.json    my_project-apigee-runtime.json
      my_project-apigee-logger.json       my_project-apigee-synchronizer.json
      my_project-apigee-mart.json         my_project-apigee-udca.json
      my_project-apigee-metrics.json      my_project-apigee-watcher.json
      

      Para obtener más información, consulta:

      • Paso 4: Crear cuentas de servicio
      • Acerca de las cuentas de servicio
3. Antes de instalar, consulta el archivo overrides.yaml para verificar la configuración:
   Importante: Apigee Hybrid v1.10.4 se actualizó con una versión de parche rápido crítico. Si lo deseas, puedes aplicar la configuración necesaria para el parche rápido directamente en el archivo de configuración de anulación que se describe en este paso. Si agregas las configuraciones de actualización ahora, no tendrás que realizar ninguna actualización de parche rápido más adelante. Los ajustes de configuración para el parche rápido (v1.10.4-hotfix.1) se enumeran en la guía de actualización. Consulta también la nota de la versión de parche rápido:

   • Hybrid v1.10.4-hotfix.1

   instanceID: UNIQUE_ID_TO_IDENTIFY_THIS_CLUSTER
   namespace: apigee # required for Helm charts installation
   
   # By default, logger and metrics are enabled and requires below details
   # Google Cloud project and cluster
   gcp:
     projectID: PROJECT_ID
     region: REGION
   
   k8sCluster:
     name: CLUSTER_NAME
     region: REGION
   
   org: ORG_NAME
   
   envs:
   - name: "ENV_NAME"
     serviceAccountPaths:
       runtime: "PATH_TO_RUNTIME_SVC_ACCOUNT"
       synchronizer: "PATH_TO_SYNCHRONIZER_SVC_ACCOUNT"
       udca: "PATH_TO_UDCA_SVC_ACCOUNT"
   
   ingressGateways:
   - name: GATEWAY_NAME # maximum 17 characters, eg: "ingress-1". See Known issue 243167389.
     replicaCountMin: 1
     replicaCountMax: 2
     svcType: LoadBalancer
   
   virtualhosts:
   - name: ENV_GROUP_NAME
     selector:
       app: apigee-ingressgateway
       ingress_name: GATEWAY_NAME
     sslSecret: SECRET_NAME
   
   mart:
     serviceAccountPath: "PATH_TO_MART_SVC_ACCOUNT"
   
   logger:
     enabled: TRUE_FALSE # lowercase without quotes, eg: true
     serviceAccountPath: "PATH_TO_LOGGER_SVC_ACCOUNT"
   
   metrics:
     enabled: TRUE_FALSE # lowercase without quotes, eg: true
     serviceAccountPath: "PATH_TO_METRICS_SVC_ACCOUNT"
   
   udca:
     serviceAccountPath: "PATH_TO_UDCA_SVC_ACCOUNT"
   
   connectAgent:
     serviceAccountPath: "PATH_TO_MART_SVC_ACCOUNT"
   
   watcher:
     serviceAccountPath: "PATH_TO_WATCHER_SVC_ACCOUNT"
   

   Esta es la misma configuración de anulación que usarás para esta instalación de Helm. Para obtener más información, consulta la Referencia de propiedad de configuración.

   Para obtener más ejemplos de archivos de anulación, consulta Paso 6: Configura el entorno de ejecución híbrido.

4. Habilita el acceso del sincronizador. Este es un requisito para instalar Apigee Hybrid.

   1. Verifica si el acceso del sincronizador ya está habilitado con los siguientes comandos:

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

      curl -X POST -H "Authorization: Bearer $TOKEN" \
        -H "Content-Type:application/json" \
        "https://apigee.googleapis.com/v1/organizations/ORG_NAME:getSyncAuthorization" \
        -d ''
      

      La respuesta debería ser similar a la siguiente:

      {
        "identities":[
           "serviceAccount:SYNCHRONIZER_SERVICE_ACCOUNT_ID"
        ],
        "etag":"BwWJgyS8I4w="
      }
      

   2. Si el resultado no incluye el ID de la cuenta de servicio, habilita el acceso del sincronizador. Tu cuenta debe tener el rol de IAM administrador de la organización de Apigee (roles/apigee.admin) para realizar esta tarea.

      curl -X POST -H "Authorization: Bearer $TOKEN" \
        -H "Content-Type:application/json" \
        "https://apigee.googleapis.com/v1/organizations/ORG_NAME:setSyncAuthorization" \
        -d '{"identities":["'"serviceAccount:SYNCHRONIZER_SERVICE_ACCOUNT_ID"'"]}'
      

      Consulta el Paso 7: Habilita el acceso del sincronizador en la documentación de instalación de Apigee Hybrid para obtener información más detallada.

5. Instala Cert Manager con el siguiente comando:

   kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.11.1/cert-manager.yaml
   

6. Instala las CRD de Apigee:

   Nota: A partir de este paso, todos los comandos se deben ejecutar en la raíz del repositorio del gráfico.
   Nota: Este es el único método compatible para instalar las CRD de Apigee. No uses kubectl apply sin -k, no omitas --server-side.
   Nota: En este paso, se requieren permisos elevados de clúster.

   1. Usa la función de ejecución de prueba kubectl mediante la ejecución del siguiente comando:

      kubectl apply -k  apigee-operator/etc/crds/default/ --server-side --force-conflicts --validate=false --dry-run=server
      

   2. Después de validar con el comando de ejecución de prueba, ejecuta el siguiente comando:

      kubectl apply -k  apigee-operator/etc/crds/default/ --server-side --force-conflicts --validate=false
      

   3. Valida la instalación con el comando kubectl get crds:

      kubectl get crds | grep apigee

      La respuesta debería ser similar a la siguiente:

      apigeedatastores.apigee.cloud.google.com                    2023-10-09T14:48:30Z
      apigeedeployments.apigee.cloud.google.com                   2023-10-09T14:48:30Z
      apigeeenvironments.apigee.cloud.google.com                  2023-10-09T14:48:31Z
      apigeeissues.apigee.cloud.google.com                        2023-10-09T14:48:31Z
      apigeeorganizations.apigee.cloud.google.com                 2023-10-09T14:48:32Z
      apigeeredis.apigee.cloud.google.com                         2023-10-09T14:48:33Z
      apigeerouteconfigs.apigee.cloud.google.com                  2023-10-09T14:48:33Z
      apigeeroutes.apigee.cloud.google.com                        2023-10-09T14:48:33Z
      apigeetelemetries.apigee.cloud.google.com                   2023-10-09T14:48:34Z
      cassandradatareplications.apigee.cloud.google.com           2023-10-09T14:48:35Z
      

7. Verifica las etiquetas existentes en los nodos del clúster. De forma predeterminada, Apigee programa los Pods de datos en los nodos con la etiqueta cloud.google.com/gke-nodepool=apigee-data y los Pods del entorno de ejecución se programan en nodos con la etiqueta cloud.google.com/gke-nodepool=apigee-runtime. Puedes personalizar las etiquetas de tu grupo de nodos en el archivo overrides.yaml.

   Para obtener más información, consulta Configura grupos de nodos dedicados.

Instala los gráficos de Helm de Apigee Hybrid

Nota: Antes de ejecutar cualquiera de los comandos de actualización o instalación de Helm, usa la función de prueba de validación de Helm; para ello, agrega --dry-run al final del comando. Consulta helm -h para enumerar los comandos, las opciones y el uso compatibles.

El

ImportanteHerramienta de migración : Si migraste tu clúster a la administración de Helm con lo siguiente:Herramienta de migración de Helm híbrida de Apigee, ya tienes recursos existentes en el clúster migrado. Para evitar borrar recursos por accidente si el comando helm upgrade falla, no uses la marca ‑‑atomic.

Por ejemplo, en el primer paso, el comando será el siguiente:

helm upgrade operator apigee-operator/ \
  --install \
  --create-namespace \
  --namespace apigee-system \
  -f overrides.yaml

1. Instala el operador o controlador de Apigee:

   Nota: En este paso, se requieren permisos elevados de clúster. Ejecuta helm -h o helm install -h para obtener más detalles

   helm upgrade operator apigee-operator/ \
     --install \
     --create-namespace \
     --namespace apigee-system \
     --atomic \
     -f overrides.yaml
   

   Importante: Omite la marca ‑‑atomic para los clústeres migrados.

   Verifica la instalación del operador de Apigee:

   helm ls -n apigee-system
   

   NAME           NAMESPACE       REVISION        UPDATED                                 STATUS          CHART                   APP VERSION
   operator    apigee-system   3               2023-06-26 00:42:44.492009 -0800 PST    deployed        apigee-operator-1.10.4   1.10.4
   

   Para verificar que esté en funcionamiento, comprueba su disponibilidad:

   kubectl -n apigee-system get deploy apigee-controller-manager
   

   NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
   apigee-controller-manager   1/1     1            1           7d20h
   

2. Instala el almacén de datos de Apigee:

   helm upgrade datastore apigee-datastore/ \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides.yaml
   

   Importante: Omite la marca ‑‑atomic para los clústeres migrados.

   Para verificar que apigeedatastore esté en funcionamiento, comprueba su estado:

   kubectl -n apigee get apigeedatastore default
   

   NAME      STATE       AGE
   default   running    2d
   

3. Instala la telemetría de Apigee:

   helm upgrade telemetry apigee-telemetry/ \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides.yaml
   

   Importante: Omite la marca ‑‑atomic para los clústeres migrados.

   Para verificar que esté en funcionamiento, comprueba su estado:

   kubectl -n apigee get apigeetelemetry apigee-telemetry
   

   NAME               STATE     AGE
   apigee-telemetry   running   2d
   

4. Instala Apigee Redis:

   helm upgrade redis apigee-redis/ \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides.yaml
   

   Importante: Omite la marca ‑‑atomic para los clústeres migrados.

   Para verificar que esté en funcionamiento, comprueba su estado:

   kubectl -n apigee get apigeeredis default
   

   NAME      STATE     AGE
   default   running   2d
   

5. Instala el administrador de entrada de Apigee:

   helm upgrade ingress-manager apigee-ingress-manager/ \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides.yaml
   

   Importante: Omite la marca ‑‑atomic para los clústeres migrados.

   Para verificar que esté en funcionamiento, comprueba su disponibilidad:

   kubectl -n apigee get deployment apigee-ingressgateway-manager
   

   NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
   apigee-ingressgateway-manager   2/2     2            2           2d
   

6. Instala la organización de Apigee:

   helm upgrade ORG_NAME apigee-org/ \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides.yaml
   

   Importante: Omite la marca ‑‑atomic para los clústeres migrados.

   Para verificar que esté en funcionamiento, comprueba el estado de la organización correspondiente:

   kubectl -n apigee get apigeeorg
   

   NAME                      STATE     AGE
   apigee-org1-xxxxx          running   2d
   

7. Instala el entorno.

   Debes instalar un entorno a la vez. Especifica el entorno con --set env=ENV_NAME:

   helm upgrade apigee-env-ENV_NAME apigee-env/ \
     --install \
     --namespace apigee \
     --atomic \
     --set env=ENV_NAME \
     -f overrides.yaml
   

   Importante: Omite la marca ‑‑atomic para los clústeres migrados.

   Para verificar que esté en funcionamiento, comprueba el estado del entorno correspondiente:

   kubectl -n apigee get apigeeenv
   

   NAME                          STATE       AGE   GATEWAYTYPE
   apigee-org1-dev-xxx            running     2d
   

8. Crea los certificados TLS. Debes proporcionar certificados TLS para la puerta de enlace de entrada del entorno de ejecución en tu configuración de Apigee Hybrid.

   1. Crea los certificados. En un entorno de producción, deberás usar certificados firmados. Puedes usar un certificado y un par de claves o un Secret de Kubernetes.

      Para la instalación de demostración y prueba, la puerta de enlace del entorno de ejecución puede aceptar credenciales autofirmadas. En el siguiente ejemplo, openssl se usa para generar las credenciales autofirmadas:

      openssl req -nodes -new -x509 \
        -keyout PATH_TO_CERTS_DIRECTORY/keystore_ENV_GROUP_NAME.key \
        -out PATH_TO_CERTS_DIRECTORY/keystore_ENV_GROUP_NAME.pem \
        -subj '/CN='YOUR_DOMAIN'' -days 3650
      

      Para obtener más información, consulta el Paso 5: Crea certificados TLS.

   2. Crea el objeto Secret de Kubernetes para hacer referencia a los certificados:

      kubectl create secret generic NAME \
        --from-file="cert=PATH_TO_CRT_FILE" \
        --from-file="key=PATH_TO_KEY_FILE" \
        -n apigee
      

9. Instala el host virtual.

   Debes instalar un grupo de entornos (virtualhost) a la vez. Especifica el grupo de entornos con --set envgroup=ENV_GROUP_NAME:

   # repeat the following command for each env group mentioned in the overrides.yaml file
   helm upgrade apigee-virtualhost-ENV_GROUP_NAME apigee-virtualhost/ \
     --install \
     --namespace apigee \
     --atomic \
     --set envgroup=ENV_GROUP_NAME \
     -f overrides.yaml
   

   Importante: Omite la marca ‑‑atomic para los clústeres migrados.
   Nota: ENV_GROUP_NAME debe ser único dentro del espacio de nombres apigee. Por ejemplo, si tienes un entorno y un grupo de entornos de prod, debes establecer este nombre en prod-envgroup. El nombre del grupo de entornos posterior debe ser prod.

   Esto crea ApigeeRouteConfig (ARC) que crea ApigeeRouter (AR) de manera interna una vez que Apigee Watcher extrae detalles relacionados con el grupo de entornos desde el plano de control. Por lo tanto, verifica que el estado de AR correspondiente esté en ejecución:

   kubectl -n apigee get arc
   

   NAME                                STATE   AGE
   apigee-org1-dev-egroup                       2d
   

   kubectl -n apigee get ar
   

   NAME                                        STATE     AGE
   apigee-org1-dev-egroup-xxxxxx                running   2d
   

Casos de uso adicionales para los gráficos de Helm con Apigee Hybrid

Copia de seguridad y restablecimiento de Cassandra

1. Para habilitar la copia de seguridad, haz lo siguiente:

   1. Actualiza los detalles de la copia de seguridad de Cassandra en el archivo overrides.yaml:

      cassandra:
        backup:
          enabled: true
          serviceAccountPath: PATH_TO_GSA_FILE
          dbStorageBucket: BUCKET_LINK
          schedule: "45 23 * * 6"
      

      Nota: Cuando usas un bucket de Cloud Storage, se debe crear una cuenta de servicio de Google Cloud apigee-cassandra-back y tener los roles o permisos adecuados para escribir en el bucket especificado en dbStorageBucket.

   2. Ejecuta la actualización de Helm en el gráfico apigee-datastore:

      helm upgrade datastore apigee-datastore/ \
        --namespace apigee \
        --atomic \
        -f overrides.yaml
      

      Importante: Omite la marca ‑‑atomic para los clústeres migrados.
2. Del mismo modo, para habilitar el restablecimiento, sigue estos pasos:

   1. Actualiza los detalles de restablecimiento de Cassandra en el archivo overrides.yaml:

      cassandra:
        restore:
          enabled: true
          snapshotTimestamp: TIMESTAMP
          serviceAccountPath: PATH_TO_GSA_FILE
          cloudProvider: "CSI"
      

   2. Ejecuta la actualización de Helm en el gráfico apigee-datastore:

      helm upgrade datastore apigee-datastore/ \
        --namespace apigee \
        --atomic \
        -f overrides.yaml
      

      Importante: Omite la marca ‑‑atomic para los clústeres migrados.

Consulta Descripción general de la copia de seguridad de Cassandra para obtener más detalles sobre la copia de seguridad y el restablecimiento de Cassandra.

Expansión multirregional

La configuración multirregional con gráficos de Helm requiere los mismos requisitos que los procedimientos apigeectl actuales. Para obtener más detalles, consulta Requisitos para implementaciones multirregionales.

El procedimiento para configurar Hybrid para varias regiones es el mismo que el procedimiento existente hasta el proceso de configuración del host de origen multirregional y de la configuración del clúster y el contexto de Kubernetes.

Configura la primera región

Sigue estos pasos para configurar la primera región y prepararte para configurar la segunda:

1. Sigue los pasos que se indican en Configura Apigee Hybrid para varias regiones para configurar el host de origen multirregional en tu plataforma.

2. Para la primera región creada, obtén los Pods en el espacio de nombres de Apigee:

   kubectl get pods -o wide -n apigee
   

3. Identifica la dirección del host de origen multirregional para Cassandra en esta región, por ejemplo, 10.0.0.11.

4. Prepara el archivo overrides.yaml para la segunda región y agrega la dirección IP del host de origen de la siguiente manera:

   cassandra:
     multiRegionSeedHost: "SEED_HOST_IP_ADDRESS"
     datacenter: "DATACENTER_NAME"
     rack: "RACK_NAME"
     clusterName: CLUSTER_NAME
     hostNetwork: false
   

   Reemplaza lo siguiente:

   • SEED_HOST_IP_ADDRESS por la dirección IP del host de origen, por ejemplo, 10.0.0.11.
   • DATACENTER_NAME por el nombre del centro de datos, por ejemplo, dc-2.
   • RACK_NAME por el nombre del bastidor, por ejemplo, ra-1.
   • CLUSTER_NAME por el nombre del clúster de Apigee. De forma predeterminada, el valor es apigeecluster. Si usas un nombre de clúster diferente, debes especificar un valor para cassandra.clusterName. Este valor debe ser el mismo en todas las regiones.

Configura la segunda región

Para configurar la región nueva, haz lo siguiente:

1. Instala cert-manager en la región 2:

   kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.11.1/cert-manager.yaml
   

2. Crea un Secret de Kubernetes para tu cuenta de servicio.
3. Crea un Secret de Kubernetes para el certificado de entrada.
4. Copia tu certificado del clúster existente en el clúster nuevo. Cassandra y otros componentes híbridos para mTLS usan la raíz de CA nueva. Por lo tanto, es fundamental tener certificados coherentes en todo el clúster.

   1. Establece el contexto en el espacio de nombres original:

      kubectl config use-context ORIGINAL_CLUSTER_NAME
      

   2. Exporta la configuración del espacio de nombres actual a un archivo:

      kubectl get namespace apigee -o yaml > apigee-namespace.yaml
      

   3. Exporta el Secret apigee-ca a un archivo:

      kubectl -n cert-manager get secret apigee-ca -o yaml > apigee-ca.yaml
      

   4. Establece el contexto en el nombre del clúster de la región nueva:

      kubectl config use-context NEW_CLUSTER_NAME
      

   5. Importa la configuración del espacio de nombres al clúster nuevo. Asegúrate de actualizar el espacio de nombres en el archivo si usas un espacio de nombres diferente en la región nueva:

      kubectl apply -f apigee-namespace.yaml
      

   6. Importa el secreto al clúster nuevo:

      kubectl -n cert-manager apply -f apigee-ca.yaml
      

5. Ahora usa gráficos de Helm para instalar Apigee Hybrid en la región nueva con los siguientes comandos del gráfico de Helm (como se hace en la región 1):

   Nota: Puedes usar las mismas CRD para una mayor coherencia; para ello, usa la misma carpeta en la que descargaste los gráficos. También puedes mantener tu archivo de anulaciones único entre la región 1 y 2; para ello, asigna a tus anulaciones un nombre único, como overrides2.yaml, etcétera.

   helm upgrade operator apigee-operator \
     --install \
     --create-namespace \
     --namespace apigee-system \
     --atomic
     -f overrides-DATACENTER_NAME.yaml
   helm upgrade datastore apigee-datastore \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides-DATACENTER_NAME.yaml
   helm upgrade telemetry apigee-telemetry \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides-DATACENTER_NAME.yaml
   helm upgrade redis apigee-redis \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides-DATACENTER_NAME.yaml
   helm upgrade ingress-manager apigee-ingress-manager \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides-DATACENTER_NAME.yaml
   helm upgrade ORG_NAME apigee-org \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides-DATACENTER_NAME.yaml
   # repeat the below command for each env mentioned on the overrides
   helm upgrade apigee-env-ENV_NAME apigee-env/ \
     --install \
     --namespace apigee \
     --atomic \
     --set env=ENV_NAME \
     -f overrides-DATACENTER_NAME.yaml
   # repeat the below command for each env group mentioned on the overrides
   helm upgrade apigee-virtualhost-ENV_GROUP_NAME apigee-virtualhost/ \
     --install \
     --namespace apigee \
     --atomic \
     --set envgroup=ENV_GROUP_NAME \
     -f overrides-DATACENTER_NAME.yaml
   

   Importante: Omite la marca ‑‑atomic para los clústeres migrados.
6. Una vez que estén instalados todos los componentes, configura Cassandra en todos los Pods de los centros de datos nuevos. Si deseas obtener instrucciones, consulta Configura Apigee Hybrid para varias regiones, selecciona tu plataforma, desplázate hasta Configura la región nueva y, luego, busca el Paso 5.
7. Una vez que se complete y verifique la replicación de datos, actualiza los hosts de origen:
   1. Quita multiRegionSeedHost: 10.0.0.11 de overrides-DATACENTER_NAME.yaml.

   2. Vuelve a aplicar el cambio para actualizar la CR del almacén de datos de Apigee:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace apigee \
        --atomic \
        -f overrides-DATACENTER_NAME.yaml
      

      Importante: Omite la marca ‑‑atomic para los clústeres migrados.

Aloja imágenes de forma privada

En lugar de depender del repositorio público de Google Cloud, tienes la opción de alojar las imágenes de forma privada. En lugar de anular cada componente, puedes agregar detalles del concentrador en las anulaciones:

hub: PRIVATE_REPO

Por ejemplo, si se proporciona el siguiente concentrador, se resolverá de forma automática la ruta de la imagen:

hub: private-docker-host.com

como:

## an example of internal component vs 3rd party
containers:
- name: apigee-udca
  image: private-docker-host.com/apigee-udca:1.10.4
  imagePullPolicy: IfNotPresent

containers:
- name: apigee-ingressgateway
  image: private-docker-host.com/apigee-asm-ingress:1.17.2-asm.8-distroless
  imagePullPolicy: IfNotPresent

Haz clic para expandir una lista de imágenes de Apigee

apigee:
  gcr.io/apigee-release/hybrid/apigee-mart-server:1.10.3
  gcr.io/apigee-release/hybrid/apigee-synchronizer:1.10.3
  gcr.io/apigee-release/hybrid/apigee-runtime:1.10.3
  gcr.io/apigee-release/hybrid/apigee-hybrid-cassandra-client:1.10.3
  gcr.io/apigee-release/hybrid/apigee-hybrid-cassandra:1.10.3
  gcr.io/apigee-release/hybrid/apigee-cassandra-backup-utility:1.10.3
  gcr.io/apigee-release/hybrid/apigee-udca:1.10.3
  gcr.io/apigee-release/hybrid/apigee-connect-agent:1.10.3
  gcr.io/apigee-release/hybrid/apigee-watcher:1.10.3
  gcr.io/apigee-release/hybrid/apigee-operators:1.10.3
  gcr.io/apigee-release/hybrid/apigee-redis:1.10.3
  gcr.io/apigee-release/hybrid/apigee-mint-task-scheduler:1.10.3

third party:
  gcr.io/apigee-release/hybrid/apigee-stackdriver-logging-agent:1.9.12-2
  gcr.io/apigee-release/hybrid/apigee-prom-prometheus:v2.45.0
  gcr.io/apigee-release/hybrid/apigee-stackdriver-prometheus-sidecar:0.9.0
  gcr.io/apigee-release/hybrid/apigee-kube-rbac-proxy:v0.14.2
  gcr.io/apigee-release/hybrid/apigee-envoy:v1.27.0
  gcr.io/apigee-release/hybrid/apigee-prometheus-adapter:v0.11.0
  gcr.io/apigee-release/hybrid/apigee-asm-ingress:1.17.2-asm.8-distroless
  gcr.io/apigee-release/hybrid/apigee-asm-istiod:1.17.2-asm.8-distroless
  gcr.io/apigee-release/hybrid/apigee-fluent-bit:2.1.8

Para mostrar una lista de las imágenes de Apigee alojadas en el repositorio de Google Cloud en la línea de comandos, haz lo siguiente:

./apigee-operator/etc/tools/apigee-pull-push.sh --list

Tolerancias

Para usar la función de Taints y tolerancias de Kubernetes, debes definir la propiedad de anulación tolerations de cada componente de Apigee Hybrid. Los siguientes componentes admiten la definición de tolerancias:

• ao
• apigeeIngressGateway
• cassandra
• cassandraSchemaSetup
• cassandraSchemaValidation
• cassandraUserSetup
• connectAgent
• istiod
• logger
• mart
• metrics
• mintTaskScheduler
• redis
• runtime
• synchronizer
• udca
• Watcher

Consulta Referencia de propiedad de configuración para obtener más información sobre estos componentes.

Por ejemplo, para aplicar las tolerancias a la implementación del operador de Apigee, haz lo siguiente:

ao:
  tolerations:
  - key: "key1"
    operator: "Equal"
    value: "value1"
    effect: "NoExecute"
    tolerationSeconds: 3600

Para aplicar las tolerancias al StatefulSet de Cassandra, sigue estos pasos:

cassandra:
  tolerations:
  - key: "key1"
    operator: "Equal"
    value: "value1"
    effect: "NoExecute"
    tolerationSeconds: 3600