Instala Apigee en Google Distributed Cloud aislado

En esta guía, se describe cómo instalar y, luego, implementar Apigee Edge para Private Cloud y proxies de API en un entorno de Google Distributed Cloud (GDC) aislado. Las ofertas de GDC aisladas, incluido Apigee Edge para Private Cloud, no requieren conectividad a Google Cloud para administrar la infraestructura y los servicios. Puedes usar un plano de control local alojado en tus instalaciones para todas las operaciones. Para obtener una descripción general de GDC aislado, consulta la descripción general.

Esta guía está dirigida a los operadores de Apigee que conocen Apigee Edge para la nube privada y tienen un conocimiento básico de Kubernetes.

Descripción general de los pasos requeridos

Para instalar y, luego, implementar Apigee Edge para Private Cloud en un entorno de GDC aislado, el operador debe completar los siguientes pasos:

Antes de comenzar

Antes de comenzar el proceso de instalación, asegúrate de completar los siguientes pasos:

  1. Crea un proyecto de GDC para usarlo en la instalación, si aún no tienes uno. Para obtener más información, consulta Cómo crear un proyecto.
  2. Descarga, instala y configura la CLI de gdcloud en una estación de trabajo conectada a GDC o dentro del entorno de implementación continua de tu organización.
  3. Obtén las credenciales necesarias para usar la CLI de gdcloud y la API de kubectl. Consulta Cómo autenticar tu cuenta para obtener acceso para conocer los pasos necesarios.
  4. Confirma el nombre de usuario y la contraseña de Apigee que recibiste de tu administrador de cuentas de Apigee.
  5. Confirma el nombre de tu clúster de administrador de GKE y el nombre de tu clúster de usuario de GKE.

Requisitos de capacidad

La instalación de Apigee Edge para Private Cloud en GDC requiere varias máquinas virtuales (VMs) con asignaciones de recursos específicos. Estas VMs generan cargos según sus recursos de procesamiento (RAM, núcleos de CPU virtuales) y el almacenamiento en disco local. Para obtener más información, consulta Precios.

En la siguiente tabla, se muestran los requisitos de recursos para cada VM:

Tipo de VM RAM Núcleos de CPU virtual Almacenamiento en disco
Nodo de repo 8 GB 2 núcleos de CPU virtuales 64 GB
Nodo de control 8 GB 2 núcleos de CPU virtuales 64 GB
Nodos 1, 2 y 3 de administración de APIs de Apigee 16 GB de RAM 8 núcleos de CPU virtuales 670 GB
Nodos 4 y 5 de administración de APIs de Apigee 16 GB de RAM 8 núcleos de CPU virtuales 500 GB a 1 TB

Funciones y permisos

Se requieren los siguientes roles y permisos para implementar Apigee Edge para la nube privada en un entorno de GDC aislado:

  • Administrador de la plataforma (PA): Asigna el rol IAM Admin.
  • Operador de la aplicación (AO): Asigna los siguientes roles:
    • Harbor Instance Admin: Tiene acceso completo para administrar instancias de Harbor en un proyecto.
    • LoggingTarget Creator: Crea recursos personalizados de LoggingTarget en el espacio de nombres del proyecto.
    • LoggingTarget Editor: Edita recursos personalizados de LoggingTarget en el espacio de nombres del proyecto.
    • Project Bucket Admin: Administra los buckets de almacenamiento y los objetos dentro de los buckets.
    • Project Grafana Viewer: Accede a la instancia de supervisión en el espacio de nombres del proyecto.
    • Project NetworkPolicy Admin: Administra las políticas de red del proyecto en el espacio de nombres del proyecto.
    • Project VirtualMachine Admin: Administra las máquinas virtuales en el espacio de nombres del proyecto.
    • Secret Admin: Administra los secretos de Kubernetes en los proyectos.
    • Service Configuration Admin: Tiene acceso de lectura y escritura a las configuraciones de servicio dentro de un espacio de nombres del proyecto.
    • Namespace Admin: Administra todos los recursos dentro de los espacios de nombres del proyecto.

    • Para obtener más información sobre cómo otorgar roles y permisos de GDC aislados, consulta Otorga y revoca el acceso.

    Limitaciones

    Se aplican las siguientes limitaciones a Apigee en GDC aislado del aire:

    • Apigee en GDC aislado no incluye servidores DNS y usa la resolución de DNS local como solución alternativa. Si Apigee en GDC aislado del aire se implementa en un entorno con servidores DNS externos, reemplaza los pasos que configuran el DNS local por la configuración de entradas DNS en los servidores DNS.
    • Apigee en GDC aislado no incluye un servidor SMTP independiente. Puedes configurar un servidor SMTP en cualquier momento para habilitar las notificaciones por correo electrónico salientes para la creación de cuentas y el restablecimiento de contraseñas desde el servidor de administración y la IU de administración. Las APIs de administración siguen disponibles para la administración de cuentas de usuario de Apigee. Consulta Cómo configurar el servidor SMTP de Edge para obtener más información.
    • Apigee en GDC aislado no implementa la detección y prevención de intrusiones. Instala y configura un sistema de prevención de intrusiones (IPS), como Snort, para detectar y prevenir actividades maliciosas.

    Obtén los archivos necesarios

    Para obtener los archivos de instalación, primero debes configurar un nodo conectado y, luego, descargar los archivos.

    Configura un nodo conectado

    El nodo conectado es una sola VM fuera de GDC que usas para descargar los archivos de instalación. Esta VM requiere acceso a Internet y solo se usa para el proceso de instalación.

    El nodo conectado requiere la siguiente capacidad y configuración:

    • Sistema operativo: Rocky Linux 8
    • Tamaño de la máquina: 8 GB de RAM, 2 núcleos de CPU virtuales y 64 GB de almacenamiento en disco local
    • Conectividad:
      • Entrada: TCP 22 (SSH)
      • Salida: Internet

    Para crear el nodo conectado, sigue las instrucciones que se indican en Crea e inicia una instancia de VM. Una vez que se cree la VM, sigue las instrucciones que se indican en Conéctate a VMs de Linux. para conectarte a la VM. Consulta Sistemas operativos compatibles con GDC para obtener una lista de los sistemas operativos compatibles.

    Descarga archivos de instalación

    Para descargar los archivos de instalación, haz lo siguiente:

    1. Consulta las notas de la versión de Apigee Edge para Private Cloud para conocer la versión oficial más reciente compatible con GDC, como se indica en la columna de Edge para Private Cloud.
    2. Descarga el archivo de configuración de Edge: 
      curl https://software.apigee.com/apigee/tarball/VERSION/rocky8/archive.tar -o /tmp/archive.tar -u 'APIGEE_USER:APIGEE_PASSWORD'

      Donde:

      • APIGEE_USER es el nombre de usuario que recibiste para la organización de Apigee.
      • APIGEE_PASSWORD es la contraseña que recibiste para la organización de Apigee.
      • VERSION es la versión de lanzamiento de Apigee Edge para la nube privada que se usará en GDC que planeas instalar, por ejemplo, 4.53.01.
    3. Descarga el archivo bootstrap_VERSION.sh más reciente de Apigee Edge para la nube privada en /tmp/bootstrap_VERSION.sh: 
      curl https://software.apigee.com/bootstrap_VERSION.sh -o /tmp/bootstrap_VERSION.sh

      Aquí, VERSION es la versión de lanzamiento más reciente de Apigee Edge para la nube privada que deseas instalar en GDC, por ejemplo, 4.53.01.

    4. Instala la utilidad apigee-service de Edge y las dependencias: 
      sudo bash /tmp/bootstrap_VERSION.sh apigeeuser=APIGEE_USER apigeepassword=APIGEE_PASSWORD

      Donde:

      • APIGEE_USER es el nombre de usuario que recibiste para la organización de Apigee.
      • APIGEE_PASSWORD es la contraseña que recibiste para la organización de Apigee.
      • VERSION es la versión de lanzamiento de Apigee Edge para Private Cloud que deseas instalar en GDC.

    5. Ejecuta la secuencia de comandos de configuración en el nodo conectado: 
      chmod a+x connected-node_setup.sh \
  ./connected-node_setup.sh

      En este paso, la secuencia de comandos genera los archivos necesarios en las siguientes ubicaciones (por ejemplo, para la versión 4.53.01):

      • /opt/apigee/data/apigee-mirror/apigee-4.53.01.tar.gz
      • /tmp/apigee-nginx/apigee-nginx.tar
      • /tmp/fluentbit/fluentbit.tar
      • /tmp/postgresql14/postgresql14.tar
      • /tmp/ansible-rpms.tar
      • /tmp/apigee-repos.tar
    6. Transfiere los archivos necesarios del nodo conectado a una máquina local a través de SSH: 
      mkdir apigee-files
cd apigee-files
for file in /opt/apigee/data/apigee-mirror/apigee-4.53.01.tar.gz /tmp/ansible-rpms.tar /tmp/apigee-nginx/apigee-nginx.tar /tmp/fluentbit/fluentbit.tar /tmp/postgresql14/postgresql14.tar /tmp/apigee-repos.tar; do
  scp -i SSH_PRIVATE_KEY_FILE USER@CONNECTED_NODE_IP:$file .
  done

      Donde:

      • SSH_PRIVATE_KEY_FILE es la ruta de acceso al archivo de claves privadas SSH.
      • USER es el nombre de usuario del nodo conectado.
      • CONNECTED_NODE_IP es la dirección IP del nodo conectado.

    Configura el bucket de almacenamiento

    En este paso, el operador de GDC configura un bucket de almacenamiento en el proyecto de GDC para almacenar los archivos de copia de seguridad de Apigee Edge para la nube privada.

    Crea un bucket de almacenamiento

    Para crear un bucket de almacenamiento en el proyecto de GDC, haz lo siguiente:

    1. Autentícate con el clúster de administrador de la organización: 
      gdcloud auth login --login-config-cert WEB_TLS_CERT
gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      Donde:

      • WEB_TLS_CERT es la ruta de acceso al certificado TLS web.
      • ORG_ADMIN_CLUSTER es el nombre del clúster de GKE del administrador de la organización.

    2. Configura las variables de entorno del proyecto y el bucket: 
      export PROJECT=PROJECT
export BUCKET=BUCKET_NAME

      Donde:

      • PROJECT es el nombre de tu proyecto de GDC.
      • BUCKET_NAME es el nombre del bucket que deseas crear para almacenar los archivos de copia de seguridad de Apigee Edge para Private Cloud.
    3. Aplica la configuración del bucket: 
      kubectl apply -f - <<EOF
apiVersion: object.GDC.goog/v1
kind: Bucket
metadata:
  name: $BUCKET
  namespace:$PROJECT
spec:
  description: bucket for Apigee backup files
  storageClass: Standard
  bucketPolicy :
    lockingPolicy :
      defaultObjectRetentionDays: 30
EOF

      Esta configuración crea un bucket con un período de retención de 30 días.

    Configura el acceso al bucket

    Para configurar el acceso al bucket de almacenamiento, haz lo siguiente:

    1. Crea una cuenta de servicio en el proyecto: 
      gdcloud iam service-accounts create $BUCKET-sa \
    --project=$PROJECT
    2. Crea el rol y la vinculación del rol para generar un secreto para acceder al bucket: 
      kubectl apply -f - <<EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: $BUCKET-role
  namespace: $PROJECT
rules:
-   apiGroups:
  -   object.gdc.goog
  resourceNames:
  -   $BUCKET
  resources:
  -   buckets
  verbs:
  -   get
  -   read-object
  -   write-object
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: $BUCKETrolebinding
  namespace: $PROJECT
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: $BUCKET-role
subjects:
-   kind: ServiceAccount
  name: $BUCKET-sa
  namespace: $PROJECT
EOF
    3. Obtén el ID de clave de acceso y la clave del secreto: 
      export BUCKET_SECRET=$(kubectl get secret -n $PROJECT -o jsonpath="{range .items[*]}{.metadata.name}{':'}{.metadata.annotations['object\.GDC\.goog/subject']}{'\n'}{end}" | grep $BUCKET | tail -1 | cut -f1 -d :)
echo "access-key-id=$(kubectl get secret -n $PROJECT $BUCKET_SECRET -o jsonpath="{.data['access-key-id']}")"
echo "access-key=$(kubectl get secret -n $PROJECT $BUCKET_SECRET -o jsonpath="{.data['secret-access-key']}")"

      El resultado debería ser similar al siguiente: 

      access-key-id=RFdJMzRROVdWWjFYNTJFTzJaTk0=
access-key=U3dSdm5FRU5WdDhMckRMRW1QRGV0bE9MRHpCZ0Ntc0cxVFJQdktqdg==
    4. Crea un secreto para que el cargador lo use en el clúster de GKE del usuario:
      1. Autentícate con el clúster de GKE del usuario: 
        gdcloud clusters get-credentials USER_CLUSTER

        Aquí USER_CLUSTER es el nombre del clúster de GKE del usuario.

      2. Aplica la configuración del secreto: 
        kubectl apply -f - <<EOF
apiVersion: v1
kind: Secret
metadata:
  namespace: $PROJECT
  name: $BUCKET-secret
type: Opaque
data:
  access-key-id: ACCESS_KEY_ID
  access-key: ACCESS_KEY
EOF

        Donde:

        • ACCESS_KEY_ID es el ID de la clave de acceso que obtuviste en el paso anterior.
        • ACCESS_KEY es la clave de acceso que obtuviste en el paso anterior.
    5. Obtén el extremo de almacenamiento, el nombre de dominio completamente calificado (FQDN) y la región del bucket:
      1. Autentícate con el clúster de administrador de la organización: 
        gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

        Aquí, ORG_ADMIN_CLUSTER es el nombre del clúster de GKE del administrador de la organización.

      2. Obtén el extremo de almacenamiento, el nombre de dominio completamente calificado (FQDN) y la región del bucket: 
        kubectl get buckets ${BUCKET} -n $PROJECT -o jsonpath="{'endpoint: '}{.status.endpoint}{'\n'}{'bucket: '}{.status.fullyQualifiedName}{'\n'}{'region: '}{.status.region}{'\n'}"

        El resultado debería ser similar al siguiente:

        endpoint: https://objectstorage.gpu-org.cookie.sesame.street
bucket: ez9wo-apigee-backup-bucket
region: cookie
    6. Actualiza los siguientes valores en el archivo apigee/helm_user_cluster/values-cookie-air-gapped.yaml: 
      objectstorekeyname: "apigee-backup-bucket-secret"
objectstoreurl: "BUCKET_ENDPOINT"
objectstorebucket: "BUCKET_FQDN"

      Donde:

      • BUCKET_ENDPOINT es el extremo del bucket que se obtuvo en el paso anterior.
      • BUCKET_FQDN es el nombre de dominio completamente calificado del bucket que se obtuvo en el paso anterior.

    Configura el nodo del repositorio

    En este paso, el operador de GDC configura un nodo de repositorio para alojar el repositorio duplicado de Apigee Edge para la nube privada.

    Crea un nodo de repositorio

    Para crear un nodo de repositorio, haz lo siguiente:

    1. Actualiza apigee/helm_user_cluster/values-cookie-air-gapped.yaml de la siguiente manera: 
      repo_node:
  enabled: true

apigee_node:
  enabled: false

control_node:
  enabled: false

      Asegúrate de que repo_node esté habilitado y que apigee_node y control_node estén inhabilitados. Estos nodos se implementarán en un paso posterior.

    2. Obtén credenciales para el clúster de administrador de la organización: 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      Aquí, ORG_ADMIN_CLUSTER es el nombre del clúster de GKE del administrador de la organización.

    3. Crea un entorno virtual de Python: 
      python3 -m venv venv /
source venv/bin/activate
    4. Ejecuta la secuencia de comandos de implementación para crear el nodo del repositorio: 
      python apigee/solution_deploy.py gdc-air-gapped

    Configura el acceso a nodos del repositorio

    Para configurar el acceso al nodo del repositorio, haz lo siguiente:

    1. Configura SSH para el nodo del repositorio: 
      export NODE=repo
kubectl create -n $PROJECT -f - <<EOF
  apiVersion: virtualmachine.GDC.goog/v1
  kind: VirtualMachineAccessRequest
  metadata:
    generateName: $NODE-
  spec:
    ssh:
      key: |
        "cat SSH_PUBLIC_KEY_FILE"
  ttl: 24h
  user: admin
  vm: $NODE
  EOF

      Aquí SSH_PUBLIC_KEY_FILE es el nombre del archivo que contiene tu llave SSH pública.

    2. Obtén la dirección IP externa del nodo del repositorio: 
      kubectl get virtualmachineexternalaccess -n $PROJECT $NODE -ojsonpath='{.status.ingressIP}'
    3. Obtén la dirección IP interna del nodo del repositorio: 
      kubectl get virtualmachines.virtualmachine.gdc.goog -n $PROJECT $NODE -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

    Sube archivos de instalación

    En este paso, el operador de GDC sube la versión más reciente de los siguientes archivos al nodo del repositorio:

    • apigee-4.53.01
    • apigee-nginx.tar
    • postgresql14.tar
    • fluentbit.tar
    • ansible-rpms.tar
    • apigee-repos.tar

    Para subir los archivos de instalación, haz lo siguiente:

    1. Copia el archivo de claves privadas SSH en el nodo del repositorio: 
      scp -i SSH_PRIVATE_KEY_FILE ~/apigee-files/* admin@REPO_EXTERNAL_IP:/tmp

      Donde:

      • SSH_PRIVATE_KEY_FILE es el nombre del archivo que contiene tu clave SSH privada.
      • REPO_EXTERNAL_IP es la dirección IP externa del nodo del repositorio que obtuviste en el paso anterior.
    2. Sube la carpeta que contiene las configuraciones de Fluent Bit al nodo del repositorio: 
      scp -i SSH-PRIVATE-KEY-FILE -r apigee/scripts/fluent-bit admin@REPO_EXTERNAL_IP:/tmp/fluent-bit

      Donde:

      • SSH_PRIVATE_KEY_FILE es el nombre del archivo que contiene tu clave SSH privada.
      • REPO_EXTERNAL_IP es la dirección IP externa del nodo del repositorio.

    Configura el repositorio duplicado

    Para configurar el repositorio de duplicación, haz lo siguiente:

    1. Copia apigee/scripts/repo_setup.sh en el nodo del repositorio.
    2. En la secuencia de comandos, reemplaza REPO_USER y REPO_PASSWORD por el nombre de usuario y la contraseña deseados para el repositorio duplicado.
    3. Ejecuta la secuencia de comandos: 
      chmod a+x repo_setup.sh
./repo_setup.sh

      Si encuentras un error No such file or directory, vuelve a ejecutar la secuencia de comandos.

    4. Prueba la conexión al repositorio duplicado de forma local desde el nodo del repositorio. 
      curl http://REPO_USER:REPO_PASSWORD@REPO_INTERNAL_IP:3939/bootstrap_VERSION.sh -o /tmp/bootstrap_VERSION.sh
curl http://REPO_USER:REPO_PASSWORD@REPO_INTERNAL_IP:3939/apigee/release/VERSION/repodata/repomd.xml

      Reemplaza VERSION por la versión de Apigee Edge para la nube privada que deseas instalar.

    Implementa nodos de Apigee

    En este paso, el operador de GDC implementa los nodos de administración de la API de Apigee.

    Crea nodos de Apigee

    Para crear los nodos de administración de la API de Apigee, haz lo siguiente:

    1. Reemplaza REPO_INTERNAL_IP, REPO_USER_NAME y REPO_PASSWORD en apigee/helm/scripts/apigee_setup.sh por los valores deseados.
    2. Exporta los valores como variables de entorno: 
      export REPO_IP=REPO_INTERNAL_IP
export REPO_USER=REPO_USER_NAME
export REPO_PASSWORD=REPO_PASSWORD
    3. Habilita apigee_node en apigee/helm/values-cookie-air-gapped.yaml como se muestra a continuación: 
      apigee_node:
  enabled: true
    4. Ejecuta la secuencia de comandos de implementación para crear los nodos de Apigee: 
        source venv/bin/activate
  python apigee/solution_deploy.py gdc-air-gapped

    Configura el acceso a los nodos de Apigee

    Configura el acceso a los nodos de administración de la API de Apigee:

    1. Autentícate con el clúster de administrador de la organización: 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      Aquí, ORG_ADMIN_CLUSTER es el nombre del clúster de GKE del administrador de la organización.

    2. Crea una clave SSH para cada nodo: 
      for i in 1 2 3 4 5; do
  kubectl create -n $PROJECT -f - <<EOF
  apiVersion: virtualmachine.GDC.goog/v1
  kind: VirtualMachineAccessRequest
  metadata:
    generateName: node$i
  spec:
    ssh:
      key: |
        "cat SSH_PUBLIC_KEY_FILE"
  ttl: 24h
  user: admin
  vm: node$i
  EOF
  done

      Aquí SSH_PUBLIC_KEY_FILE es el nombre del archivo que contiene tu llave SSH pública.

    3. Obtén las direcciones IP externas de los nodos de Apigee: 
      for i in 1 2 3 4 5; do
  kubectl get virtualmachineexternalaccess -n $PROJECT node$i -ojsonpath='{.status.ingressIP}'
  echo
  done
    4. Obtén las direcciones IP internas de los nodos de Apigee: 
      for i in 1 2 3 4 5; do
  kubectl get virtualmachines.virtualmachine.gdc.goog -n $PROJECT node$i -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'
  echo
  done
    5. (Opcional) Verifica si las secuencias de comandos de inicio se ejecutan correctamente en los nodos de Apigee:
      1. Establece una conexión SSH al nodo y ejecuta el siguiente comando: 
        sudo journalctl -u cloud-final -f
      2. Busca registros similares a los siguientes: 
        Aug 29 18:17:00 172.20.128.117 cloud-init[1895]: Complete!
Aug 29 18:17:00 172.20.128.117 cloud-init[1895]: Finished running the command: . /var/lib/google/startup-scripts/apigee-setup

    Configura el nodo de control

    En este paso, el operador de GDC configura un nodo de control para administrar las instalaciones de Apigee.

    Crea un nodo de control

    Para crear un nodo de control, haz lo siguiente:

    1. Reemplaza REPO_INTERNAL_IP, REPO_USER_NAME y REPO_PASSWORD en apigee/helm/scripts/control_setup.sh con los valores deseados.
    2. Habilita control_node en apigee/helm/values-cookie-air-gapped.yaml como se muestra a continuación: 
      control_node:
  enabled: true
    3. Ejecuta la secuencia de comandos de implementación para crear el nodo de control: 
      source venv/bin/activate
python apigee/solution_deploy.py gdc-air-gapped

    Configura el acceso al nodo de control

    Para configurar el acceso al nodo de control, sigue estos pasos:

    1. Configura el acceso SSH al nodo de control: 
      kubectl create -n $PROJECT -f - <<EOF
apiVersion: virtualmachine.GDC.goog/v1
kind: VirtualMachineAccessRequest
metadata:
  generateName: control-
spec:
  ssh:
    key: |
      "cat SSH_PUBLIC_KEY_FILE"
ttl: 24h
user: admin
vm: control
EOF
    2. Obtén la dirección IP externa del nodo de control: 
      kubectl get virtualmachineexternalaccess -n $PROJECT control -ojsonpath='{.status.ingressIP}'
    3. Obtén la IP interna del nodo de control: 
      kubectl get virtualmachines.virtualmachine.GDC.goog -n $PROJECT control -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

    Configura Ansible

    En este paso, el operador de GDC configura el entorno de en el nodo de control.

    Para configurar el entorno de Ansible, haz lo siguiente:

    1. Establece una conexión SSH al nodo de control y configura el entorno de Ansible: 
      cd /home/admin
cp -r /tmp/apigee-repos .
cd apigee-repos/ansible-opdk-accelerator/setup
    2. Reemplaza los repositorios remotos de Git por un archivo local: 
      sed -i 's/https:\/\/github.com\/carlosfrias/git+file:\/\/\/home\/admin\/apigee-repos/g'  requirements.yml
sed -i 's/\.git$//g'  requirements.yml
    3. Install Ansible requirements: 
        sudo chown -R admin /home/admin/apigee-repos
  ansible-galaxy install -r requirements.yml -f
    4. Actualiza la configuración de la instalación:
      1. Edita el archivo main.yml: 
        vi ~/apigee-repos/ansible-opdk-accelerator/setup/roles/apigee-opdk-setup-ansible-controller/tasks/main.yml
      2. Quita las tareas que necesitan acceso a GitHub:
        • Extracción de SSH de Git de repositorios de configuración
        • Extracción HTTPS de Git de repositorios de configuración
      3. Ejecuta la guía de configuración: 
        cd ~/apigee-repos/ansible-opdk-accelerator/setup
ansible-playbook setup.yml
    5. Sube la clave SSH para los nodos de Apigee al nodo de control: 
      scp -i CONTROL_SSH_PRIVATE_KEY_FILE APIGEE_NODE_SSH_PRIVATE_KEY_FILE admin@CONTROL_EXTERNAL_IP:/home/admin/.ssh/id_rsa

      Donde:

      • CONTROL_SSH_PRIVATE_KEY_FILE es el nombre del archivo que contiene la clave privada SSH de tu nodo de control.
      • APIGEE_NODE_SSH_PRIVATE_KEY_FILE es el nombre del archivo que contiene la clave privada SSH de tu nodo de Apigee.
      • CONTROL_EXTERNAL_IP es la dirección IP externa del nodo de control.
    6. Crea el archivo de configuración del inventario de Ansible:
      1. Copia el contenido del archivo apigee/scripts/ansible/prod.cfg en el archivo prod.cfg: 
        vi ~/.ansible/multi-planet-configurations/prod.cfg
      2. Crea la carpeta edge-dc1 y copia el contenido del archivo apigee/scripts/ansible/edge-dc1 en el archivo edge-dc1: 
        mkdir ~/.ansible/inventory/prod
vi ~/.ansible/inventory/prod/edge-dc1
    7. Actualiza las direcciones IP internas de los nodos de Apigee en edge-dc1: 
      apigee_000 ansible_host=APIGEE_NODE1_INTERNAL_IP
apigee_001 ansible_host=APIGEE_NODE2_INTERNAL_IP
apigee_002 ansible_host=APIGEE_NODE3_INTERNAL_IP
apigee_003 ansible_host=APIGEE_NODE4_INTERNAL_IP
apigee_004 ansible_host=APIGEE_NODE5_INTERNAL_IP

      Los valores de APIGEE_NODE*_INTERNAL_IP son las direcciones IP internas de los nodos de Apigee que se obtuvieron en un paso anterior.

    8. Configura el archivo ~/.apigee-secure/credentials.yml con los siguientes valores:
      • apigee_repo_user: 'APIGEE_REPO_USER'
      • apigee_repo_password: 'APIGEE_REPO_PASSWORD'
      • opdk_qpid_mgmt_username: 'OPDK_QPID_MGMT_USERNAME'
      • opdk_qpid_mgmt_password: 'OPDK_QPID_MGMT_PASSWORD'

      Donde:

      • APIGEE_REPO_USER es el nombre de usuario del repositorio de Apigee.
      • APIGEE_REPO_PASSWORD es la contraseña del repositorio de Apigee.
      • OPDK_QPID_MGMT_USERNAME es el nombre de usuario del servidor de administración de QPID de Apigee.
      • OPDK_QPID_MGMT_PASSWORD es la contraseña del servidor de administración de Apigee QPID.

    9. Agrega un archivo de licencia válido de Apigee Edge para la nube privada. El nombre del archivo debe ser license.txt.
    10. Copia el contenido del archivo ~/.apigee-secure/license.txt en el archivo license.txt que acabas de crear.
    11. Configura los siguientes valores en el archivo ~/.apigee/custom-properties.yml:
      • opdk_version: 'OPDK_VERSION'
      • apigee_repo_url: 'APIGEE_REPO_URL'

      Donde:

      • OPDK_VERSION es la versión de Apigee Edge para la nube privada que deseas instalar.
      • APIGEE_REPO_URL es la URL del repositorio de Apigee.

    12. Exporta el archivo de configuración como una variable de entorno: 
      export ANSIBLE_CONFIG=~/.ansible/multi-planet-configurations/prod.cfg

    Instala los componentes de Apigee

    En este paso, el operador de GDC instala los componentes de Apigee con Ansible.

    Para instalar los componentes de Apigee, haz lo siguiente:

    1. Reemplaza los repositorios de Git remotos por archivos locales: 
      cd ~/apigee-repos/ansible-opdk-accelerator/installations/multi-node/
sed -i 's/https:\/\/github.com\/carlosfrias/git+file:\/\/\/home\/admin\/apigee-repos/g' requirements.yml
sed -i 's/\.git$//g'  requirements.yml
    2. Instala los requisitos de Ansible: 
      ansible-galaxy install -r requirements.yml -f
    3. Aplica parches a los roles de Ansible: 
      sed -i 's/private_address/inventory_hostname/g' ~/.ansible/roles/apigee-opdk-settings-cassandra/tasks/main.yml
sed -i 's/include/include_tasks/g' ~/.ansible/roles/apigee-opdk-server-self/tasks/main.yml
sed -i 's/include/include_tasks/g' ~/.ansible/roles/apigee-opdk-setup-silent-installation-config/tasks/main.yml
cat << EOF >> ~/.ansible/roles/apigee-opdk-setup-silent-installation-config/templates/response-file-template.conf.j2
QPID_MGMT_USERNAME= opdk_qpid_mgmt_username
QPID_MGMT_PASSWORD= opdk_qpid_mgmt_password
EOF
sed -i 's/mode: 0700/mode: 0700\n      recurse: yes/g' ~/.ansible/roles/apigee-opdk-setup-postgres-config/tasks/main.yml
    4. Reemplaza el contenido del archivo install.yml por el contenido de apigee/scripts/ansible/install.yml.
    5. Ejecuta el playbook para instalar los componentes de Apigee: 
      ansible-playbook install.yml
    6. Inhabilita el vínculo para restablecer la contraseña del usuario en la IU de Edge. Apigee en GDC aislado no incluye un servidor SMTP. Sigue los pasos que se indican en Cómo inhabilitar el vínculo para restablecer la contraseña en la IU de Edge.

    Implementa pods y servicios

    En este paso, implementarás los Pods y servicios de carga, proxy inverso, balanceador de cargas y registro.

    Para implementar los Pods y los servicios, haz lo siguiente:

    1. Sigue las instrucciones en Crea instancias del registro de Harbor para crear una instancia de Harbor en el proyecto de GDC dev-apigee.
    2. Sigue las instrucciones que se indican en Crea proyectos de Harbor para crear un proyecto de Harbor llamado apigee.
    3. Sigue las instrucciones en Configura el control de acceso para configurar el control de acceso del proyecto de Harbor.
    4. Sigue las instrucciones en Accede a Docker y Helm para configurar la autenticación de Docker.
    5. Actualiza las direcciones IP en el archivo apigee/apigee_user_cluster.toml como se muestra a continuación: 
      mgmt-server-proxy = "APIGEE_NODE1_EXTERNAL_IP"
router-proxy1 = "APIGEE_NODE2_EXTERNAL_IP"
router-proxy2 = "APIGEE_NODE3_EXTERNAL_IP"

      Donde:

      • APIGEE_NODE1_EXTERNAL_IP es la dirección IP externa del nodo 1 de Apigee que obtuviste en un paso anterior.
      • APIGEE_NODE2_EXTERNAL_IP es la dirección IP externa del nodo2 de Apigee que obtuviste en un paso anterior.
      • APIGEE_NODE3_EXTERNAL_IP es la dirección IP externa del nodo3 de Apigee que obtuviste en un paso anterior.

    6. Coloca el archivo del certificado SSL (server.crt) y el archivo de clave (server.key) para configurar HTTPS en las carpetas apigee/mgmt-server-proxy y apigee/router-proxy.

      Para generar certificados autofirmados, usa el siguiente comando: 

      openssl req -newkey rsa:4096 -x509 -nodes -keyout server.key -new -out server.crt -subj "/CN=*.apigeetest.com" -sha256 -days 365
    7. Actualiza el valor de SSH-PASSWORD para el usuario raíz en el contenedor de carga en el archivo apigee/uploader/Dockerfile: 
      RUN echo 'root:SSH_PASSWORD' | chpasswd
    8. Obtén las credenciales del clúster de usuario: 
      gdcloud clusters get-credentials USER_CLUSTER

      Aquí USER_CLUSTER es el nombre del clúster de GKE del usuario.

    9. Ejecuta la secuencia de comandos de implementación para implementar los pods y los servicios: 
      source venv/bin/activate
python apigee/solution_deploy_user_cluster.py gdc-air-gapped
    10. Obtén las direcciones IP externas de los servicios: 
      kubectl get svc -n $PROJECT_ID

    Actualiza las IPs del cargador y del reenvío de Fluent Bit

    En este paso, actualizarás las IPs del cargador y del retransmisor de Fluent Bit en las copias de seguridad y en las secuencias de comandos de configuración de Apigee.

    1. Actualiza SSH_PASSWORD, root y UPLOADER_EXTERNAL_IP en apigee/helm/scripts/backup_setup.sh: 
      sshpass -p SSH_PASSWORD scp -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null apigee-backup* root@UPLOADER_EXTERNAL_IP:/temp/

      Donde:

      • SSH_PASSWORD es la contraseña del usuario raíz.
      • UPLOADER_EXTERNAL_IP es la dirección IP externa del servicio de carga que obtuviste en un paso anterior.

    2. Actualiza FLUENTBIT_EXTERNAL_IP en apigee/helm/scripts/apigee_setup.sh: 
      export FLUENTBIT_EXTERNAL_IP=FLUENTBIT_EXTERNAL_IP

    Para actualizar la secuencia de comandos de inicio, es necesario reiniciar los nodos de Apigee. Para reiniciar los nodos, haz lo siguiente:

    1. Detén las VMs: 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER
export PROJECT=dev-apigee
for i in 1 2 3 4 5; do
  gdcloud compute instances stop node$i --project $PROJECT
  done
    2. Vuelve a implementar el gráfico de Helm: 
      python apigee/solution_deploy.py gdc-air-gapped
    3. Inicia las VMs: 
      for i in 1 2 3 4 5; do
  GDCloud compute instances start node$i --project $PROJECT
  done

    Incorpora la organización de Apigee

    En este paso, el operador de GDC incorpora la organización de Apigee ejecutando una secuencia de comandos de configuración en node1.

    Para incorporar la organización de Apigee, haz lo siguiente:

    1. Actualiza los siguientes valores en apigee/scripts/apigee_org_setup.sh como se muestra. Actualiza otros parámetros según sea necesario. 
      IP1=APIGEE_NODE1_INTERNAL_IP

VHOST_ALIAS="APIGEE_NODE2_EXTERNAL_IP:9001 APIGEE_NODE3_EXTERNAL_IP:9001"

      Donde:

      • APIGEE_NODE1_INTERNAL_IP es la dirección IP interna del nodo1 de Apigee que obtuviste en un paso anterior.
      • APIGEE_NODE2_EXTERNAL_IP es la dirección IP externa del nodo2 de Apigee que obtuviste en un paso anterior.
      • APIGEE_NODE3_EXTERNAL_IP es la dirección IP externa del nodo3 de Apigee que obtuviste en un paso anterior.

    2. Ejecuta la secuencia de comandos en node1 para incorporar la organización: 
      chmod a+x apigee_org_setup.sh
./apigee_org_setup.sh

    Prueba la conectividad HTTP

    En este paso, probarás la conectividad HTTP para la API de Management y el proxy de API.

    Para probar la conectividad HTTP, haz lo siguiente:

    1. Obtén la dirección IP externa del servicio apigee-elb: 
      gdcloud clusters get-credentials USER_CLUSTER
export PROJECT=dev-apigee
kubectl get svc apigee-elb -n $PROJECT

      Aquí USER_CLUSTER es el nombre del clúster de GKE del usuario.

      Este servicio actúa como el extremo de la IU de Edge, la API de Management y el proxy de API.

    Prueba la API de Management

    Para probar la API de Management, envía una solicitud HTTP al extremo: 

    curl -u "opdk@apigee.com:Apigee123!" "http://APIGEE_ELB_EXTERNAL_IP:8080/v1/o/ORG_NAME/e/ENV_NAME/provisioning/axstatus"

    Donde:

    • APIGEE_ELB_EXTERNAL_IP es la dirección IP externa del servicio apigee-elb que se obtuvo en un paso anterior.
    • ORG_NAME es el nombre de la organización de Apigee.
    • ENV_NAME es el nombre del entorno de Apigee.

    Prueba el proxy de API

    Para probar el proxy de API, haz lo siguiente:

    1. Accede a la IU de Edge.
    2. En la página Proxies de API, haz clic en Crear para crear un proxy de API nuevo.
    3. En la página Detalles del proxy, ingresa los siguientes valores:
      • Tipo de proxy: Selecciona Sin destino.
      • Nombre del proxy: ok
      • Ruta base: /ok
      • Objetivo: http://APIGEE_ELB_EXTERNAL_IP:9001
    4. Haz clic en Crear para crear el proxy de API.
    5. Envía una solicitud HTTP a /ok: 
      curl -i http://APIGEE_ELB_EXTERNAL_IP:9001/ok
    6. Confirma que la respuesta sea 200 OK.

    Configura TLS y prueba HTTPS

    En este paso, el operador de GDC configura la seguridad de la capa de transporte (TLS) para el proxy de API, la IU de Edge y la API de Management.

    Configura TLS para el proxy de API

    1. Sigue los pasos que se indican en Crea un almacén de claves o de confianza y un alias para crear un certificado autofirmado con los siguientes valores:
      • KeyStore: myTestKeystore
      • KeyAlias: myKeyAlias
      • Nombre común: apigeetest.com
    2. Realiza una llamada a la API para crear el host virtual llamado api.apigeetest.com: 
      curl -v -H "Content-Type:application/xml" \
  -u "opdk@apigee.com:Apigee123!" "http://APIGEE_ELB_EXTERNAL_IP:8080/v1/o/ORG_NAME/e//virtualhosts" \
  -d '<VirtualHost  name="secure">
      <HostAliases>
        <HostAlias>api.apigeetest.com</HostAlias>
      </HostAliases>
      <Interfaces/>
      <Port>9005</Port>
      <OCSPStapling>off</OCSPStapling>
      <SSLInfo>
        <Enabled>true</Enabled>
        <ClientAuthEnabled>false</ClientAuthEnabled>
        <KeyStore>myTestKeystore</KeyStore>
        <KeyAlias>myKeyAlias</KeyAlias>
      </SSLInfo>
    </VirtualHost>'

      Donde:

      • APIGEE_ELB_EXTERNAL_IP es la dirección IP externa del servicio apigee-elb que se obtuvo en un paso anterior.
      • ORG_NAME es el nombre de la organización de Apigee.
      • ENV_NAME es el nombre del entorno de Apigee en el que se debe crear el host virtual.
    3. Crea un proxy de API con el host virtual seguro.
    4. En los routers, configura la resolución de DNS para los hosts virtuales: 
      echo '127.0.0.1 api.apigeetest.com' | sudo tee -a /etc/hosts
    5. Envía una solicitud HTTPS al extremo para confirmar que los hosts virtuales funcionen de forma local: 
      curl https://api.apigeetest.com:9005/ok -v -k
    6. Configura la resolución de DNS para el extremo: 
      echo 'APIGEE_ELB_EXTERNAL_IP apigeetest.com' | sudo tee -a /etc/hosts

      Aquí, APIGEE_ELB_EXTERNAL_IP es la dirección IP externa del servicio apigee-elb que obtuviste en un paso anterior.

    7. Navega a https://apigeetest.com/ok en un navegador web y confirma que funcione.

    Configura TLS para la IU de Edge

    Para configurar TLS para la IU de Edge, haz lo siguiente:

    1. Genera un archivo de almacén de claves a partir del archivo de certificado SSL y el archivo de claves: 
      openssl pkcs12 -export -clcerts -in server.crt -inkey server.key -out keystore.pkcs12
keytool -importkeystore -srckeystore keystore.pkcs12 -srcstoretype pkcs12 -destkeystore keystore.jks -deststoretype jks
    2. Coloca el archivo del almacén de claves en la carpeta de Apigee en node1: 
      scp -i SSH_PRIVATE_KEY_FILE keystore.jks admin@APIGEE_NODE1_EXTERNAL_IP:/home/admin/

      Donde:

      • SSH_PRIVATE_KEY_FILE es el nombre del archivo que contiene la clave privada SSH de tu nodo de Apigee.
      • APIGEE_NODE1_EXTERNAL_IP es la dirección IP externa del nodo 1 de Apigee que obtuviste en un paso anterior.

    3. Establece una conexión SSH a node1 y mueve el archivo del almacén de claves a la carpeta de Apigee: 
      sudo mv keystore.jks /opt/apigee/customer/application/
    4. Crea el archivo de configuración de SSL: 
      sudo vi /tmp/sslConfigFile
    5. Actualiza el valor de KEY-PASS-PHRASE como se muestra a continuación: 
      HTTPSPORT=9443
DISABLE_HTTP=n
KEY_ALGO=JKS
KEY_FILE_PATH=/opt/apigee/customer/application/keystore.jks
KEY_PASS=KEY_PASS_PHRASE
    6. Configura SSL con el archivo de configuración: 
      sudo chown apigee:apigee /tmp/sslConfigFile
/opt/apigee/apigee-service/bin/apigee-service edge-ui configure-ssl -f /tmp/sslConfigFile
    7. Configura la resolución de DNS para la IU de Edge: 
      echo 'APIGEE_ELB_EXTERNAL_IP ui.apigeetest.com' | sudo tee -a /etc/hosts

      Aquí, APIGEE_ELB_EXTERNAL_IP es la dirección IP externa del servicio apigee-elb que obtuviste en un paso anterior.

    8. Accede a https://ui.apigeetest.com:9443 en un navegador web y confirma que funciona. Para obtener más detalles, consulta la guía.

    Configura TLS para la API de Management

    Para configurar TLS para la API de Management, haz lo siguiente:

    1. Configura el propietario del archivo del almacén de claves (usa el mismo que la IU de Edge): 
      sudo chown apigee:apigee /opt/apigee/customer/application/keystore.jks
    2. Crea el archivo de propiedades: 
      sudo vi /opt/apigee/customer/application/management-server.properties

      3. Reemplaza el valor de KEY_PASS_PHRASE por la contraseña del almacén de claves, como se muestra a continuación: 

      conf_webserver_ssl.enabled=true
# Leave conf_webserver_http.turn.off set to false
# because many Edge internal calls use HTTP.
conf_webserver_http.turn.off=false
conf_webserver_ssl.port=8443
conf_webserver_keystore.path=/opt/apigee/customer/application/keystore.jks
# Enter the obfuscated keystore password below.
conf_webserver_keystore.password=KEY_PASS_PHRASE
    3. Reinicia el servidor de administración para que se apliquen los cambios: 
      /opt/apigee/apigee-service/bin/apigee-service edge-management-server restart
    4. Confirma que HTTPS funcione de forma local: 
      curl -u "opdk@apigee.com:Apigee123!" "https://localhost:8443/v1/users" -k
    5. Desde el cliente, accede a https://apigeetest.com:8443/v1/users en el navegador. Ingresa el nombre de usuario y la contraseña del administrador para confirmar que las credenciales estén configuradas correctamente.

    ¿Qué sigue?