Installa Apigee su Google Distributed Cloud con air gap

Questa guida descrive come installare ed eseguire il deployment di Apigee Edge for Private Cloud e dei proxy API in un ambiente Google Distributed Cloud (GDC) air-gap. Le offerte GDC con air gap, tra cui Apigee Edge per Private Cloud, non richiedono la connettività a Google Cloud per gestire l'infrastruttura e i servizi. Puoi utilizzare un control plane locale ospitato nei tuoi locali per tutte le operazioni. Per una panoramica di GDC con air gap, consulta la panoramica.

Questa guida è destinata agli operatori Apigee che conoscono Apigee Edge for Private Cloud e hanno una conoscenza di base di Kubernetes.

Panoramica dei passaggi richiesti

Per installare e implementare Apigee Edge for Private Cloud in un ambiente GDC air-gap, l'operatore deve completare i seguenti passaggi:

Prima di iniziare

Prima di iniziare la procedura di installazione, completa i seguenti passaggi:

  1. Crea un progetto GDC da utilizzare per l'installazione, se non ne hai già uno. Per saperne di più, consulta Creare un progetto.
  2. Scarica, installa e configura la CLI gdcloud su una workstation connessa a GDC o all'interno dell'ambiente di implementazione continua della tua organizzazione.
  3. Ottieni le credenziali necessarie per utilizzare l'interfaccia a riga di comando gdcloud e l'API kubectl. Consulta la sezione Autenticare l'account per l'accesso per i passaggi necessari.
  4. Conferma il nome utente e la password di Apigee che hai ricevuto dal tuo account manager Apigee.
  5. Conferma il nome del cluster di amministrazione GKE e del cluster utente GKE.

Requisiti di capacità

L'installazione di Apigee Edge for Private Cloud su GDC richiede diverse macchine virtuali (VM) con allocazioni di risorse specifiche. Queste VM comportano costi in base alle risorse di calcolo (RAM, core vCPU) e allo spazio di archiviazione su disco locale. Per ulteriori informazioni, vedi Prezzi.

La tabella seguente mostra i requisiti delle risorse per ogni VM:

Tipo di VM RAM Core vCPU Archiviazione disco
Nodo Repo 8 GB Core vCPU 64 GB
Nodo di controllo 8 GB Core vCPU 64 GB
Nodi di gestione delle API Apigee 1, 2 e 3 16 GB di RAM 8 core vCPU 670 GB
Nodi di gestione delle API Apigee 4 e 5 16 GB di RAM 8 core vCPU 500 GB - 1TB

Ruoli e autorizzazioni

Per eseguire il deployment di Apigee Edge for Private Cloud in un ambiente GDC air-gap, sono necessari i seguenti ruoli e autorizzazioni:

  • Amministratore della piattaforma (PA): assegna il ruolo IAM Admin.
  • Operatore applicazione (AO): assegna i seguenti ruoli:
    • Harbor Instance Admin: Dispone dell'accesso completo per gestire le istanze Harbor in un progetto.
    • LoggingTarget Creator: crea risorse personalizzate LoggingTarget nello spazio dei nomi del progetto.
    • LoggingTarget Editor: Modifica le risorse personalizzate LoggingTarget nello spazio dei nomi del progetto.
    • Project Bucket Admin: gestisce i bucket di archiviazione e gli oggetti all'interno dei bucket
    • Project Grafana Viewer: Accede all'istanza di monitoraggio nello spazio dei nomi del progetto.
    • Project NetworkPolicy Admin: Gestisce le policy di rete del progetto nello spazio dei nomi del progetto.
    • Project VirtualMachine Admin: Gestisce le macchine virtuali nello spazio dei nomi del progetto.
    • Secret Admin: gestisce i secret Kubernetes nei progetti.
    • Service Configuration Admin: Dispone dell'accesso in lettura e scrittura alle configurazioni del servizio all'interno di uno spazio dei nomi del progetto.
    • Namespace Admin: Gestisce tutte le risorse all'interno degli spazi dei nomi del progetto.

    • Per scoprire di più sulla concessione di ruoli e autorizzazioni air-gap di GDC, consulta Concedere e revocare l'accesso.

    Limitazioni

    Ad Apigee su GDC air-gapped si applicano le seguenti limitazioni:

    • Apigee su GDC air-gapped non include server DNS e utilizza la risoluzione DNS locale come soluzione alternativa. Se Apigee su GDC air-gapped viene implementato in un ambiente con server DNS esterni, sostituisci i passaggi che configurano il DNS locale con la configurazione delle voci DNS nei server DNS.
    • Apigee su GDC air-gapped non include un server SMTP autonomo. Puoi configurare un server SMTP in qualsiasi momento per attivare le notifiche email in uscita per la creazione dell'account e i reimpostazioni della password dal server di gestione e dalla UI di gestione. Le API di gestione rimangono disponibili per la gestione degli account utente Apigee. Per ulteriori informazioni, consulta Configurazione del server SMTP Edge.
    • Apigee su GDC air-gapped non implementa il rilevamento e la prevenzione delle intrusioni. Installa e configura un sistema di prevenzione delle intrusioni (IPS), ad esempio Snort, per rilevare e prevenire attività dannose.

    Ottenere i file richiesti

    Per ottenere i file di installazione, devi prima configurare un nodo connesso e poi scaricare i file.

    Configurare un nodo connesso

    Il nodo connesso è una singola VM al di fuori di GDC che utilizzi per scaricare i file di installazione. Questa VM richiede l'accesso a internet e viene utilizzata solo per il processo di installazione.

    Il nodo connesso richiede la seguente capacità e configurazione:

    • Sistema operativo:Rocky Linux 8
    • Dimensioni macchina: 8 GB di RAM; 2 core vCPU; 64 GB di spazio di archiviazione su disco locale
    • Connettività:
      • Ingresso:TCP 22 (SSH)
      • Traffico in uscita:internet

    Per creare il nodo connesso, segui le istruzioni riportate in Creare e avviare un'istanza VM. Una volta creata la VM, segui le istruzioni riportate in Connessione alle VM Linux. per connetterti alla VM. Consulta Sistemi operativi supportati da GDC per un elenco dei sistemi operativi supportati.

    Scaricare i file di installazione

    Per scaricare i file di installazione:

    1. Consulta le note di rilascio di Apigee Edge per Private Cloud per la versione ufficiale più recente supportata per GDC, come indicato nella colonna Edge per Private Cloud.
    2. Scarica il file di configurazione di Edge: 
      curl https://software.apigee.com/apigee/tarball/VERSION/rocky8/archive.tar -o /tmp/archive.tar -u 'APIGEE_USER:APIGEE_PASSWORD'

      Dove:

      • APIGEE_USER è il nome utente che hai ricevuto per l'organizzazione Apigee.
      • APIGEE_PASSWORD è la password che hai ricevuto per l'organizzazione Apigee.
      • VERSION è la versione di Apigee Edge for Private Cloud da utilizzare su GDC che intendi installare, ad esempio 4.53.01.
    3. Scarica l'ultimo file bootstrap_VERSION.sh di Apigee Edge for Private Cloud in /tmp/bootstrap_VERSION.sh: 
      curl https://software.apigee.com/bootstrap_VERSION.sh -o /tmp/bootstrap_VERSION.sh

      Dove VERSION è l'ultima versione di Apigee Edge for Private Cloud da utilizzare su GDC che intendi installare, ad esempio 4.53.01.

    4. Installa l'utilità e le dipendenze di Edge apigee-service: 
      sudo bash /tmp/bootstrap_VERSION.sh apigeeuser=APIGEE_USER apigeepassword=APIGEE_PASSWORD

      Dove:

      • APIGEE_USER è il nome utente che hai ricevuto per l'organizzazione Apigee.
      • APIGEE_PASSWORD è la password che hai ricevuto per l'organizzazione Apigee.
      • VERSION è la versione di Apigee Edge for Private Cloud da utilizzare su GDC che intendi installare.

    5. Esegui lo script di configurazione sul nodo collegato: 
      chmod a+x connected-node_setup.sh \
  ./connected-node_setup.sh

      In questo passaggio, lo script genera i file necessari nelle seguenti posizioni (ad esempio, per la versione 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. Trasferisci i file richiesti dal nodo connesso a una macchina locale tramite 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

      Dove:

      • SSH_PRIVATE_KEY_FILE è il percorso del file della chiave privata SSH.
      • USER è il nome utente del nodo connesso.
      • CONNECTED_NODE_IP è l'indirizzo IP del nodo connesso.

    Configura il bucket di archiviazione

    In questo passaggio, l'operatore GDC configura un bucket di archiviazione nel progetto GDC per archiviare i file di backup di Apigee Edge for Private Cloud.

    Crea un bucket di archiviazione

    Per creare un bucket di archiviazione nel progetto GDC:

    1. Esegui l'autenticazione sul cluster dell'amministratore dell'organizzazione: 
      gdcloud auth login --login-config-cert WEB_TLS_CERT
gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      Dove:

      • WEB_TLS_CERT è il percorso del certificato TLS web.
      • ORG_ADMIN_CLUSTER è il nome del cluster GKE di amministrazione dell'organizzazione.

    2. Imposta le variabili di ambiente del progetto e del bucket: 
      export PROJECT=PROJECT
export BUCKET=BUCKET_NAME

      Dove:

      • PROJECT è il nome del tuo progetto GDC.
      • BUCKET_NAME è il nome del bucket che vuoi creare per archiviare i file di backup di Apigee Edge for Private Cloud.
    3. Applica la configurazione 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

      Questa configurazione crea un bucket con un periodo di conservazione di 30 giorni.

    Configurare l'accesso al bucket

    Per configurare l'accesso al bucket di archiviazione:

    1. Crea un service account nel progetto: 
      gdcloud iam service-accounts create $BUCKET-sa \
    --project=$PROJECT
    2. Crea il ruolo e l'associazione dei ruoli per generare un secret per l'accesso 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. Ottieni l'ID chiave di accesso e la chiave dal secret: 
      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']}")"

      L'output dovrebbe essere simile al seguente: 

      access-key-id=RFdJMzRROVdWWjFYNTJFTzJaTk0=
access-key=U3dSdm5FRU5WdDhMckRMRW1QRGV0bE9MRHpCZ0Ntc0cxVFJQdktqdg==
    4. Crea un secret da utilizzare per il caricamento nel cluster GKE utente:
      1. Esegui l'autenticazione sul cluster GKE utente: 
        gdcloud clusters get-credentials USER_CLUSTER

        dove USER_CLUSTER è il nome del cluster GKE dell'utente.

      2. Applica la configurazione del secret: 
        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

        Dove:

        • ACCESS_KEY_ID è l'ID chiave di accesso ottenuto nel passaggio precedente.
        • ACCESS_KEY è la chiave di accesso ottenuta nel passaggio precedente.
    5. Recupera l'endpoint di archiviazione, il nome di dominio completo (FQDN) e la regione del bucket:
      1. Esegui l'autenticazione sul cluster dell'amministratore dell'organizzazione: 
        gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

        dove ORG_ADMIN_CLUSTER è il nome del cluster GKE di amministrazione dell'organizzazione.

      2. Recupera l'endpoint di archiviazione, il nome di dominio completo (FQDN) e la regione del bucket: 
        kubectl get buckets ${BUCKET} -n $PROJECT -o jsonpath="{'endpoint: '}{.status.endpoint}{'\n'}{'bucket: '}{.status.fullyQualifiedName}{'\n'}{'region: '}{.status.region}{'\n'}"

        L'output dovrebbe essere simile al seguente:

        endpoint: https://objectstorage.gpu-org.cookie.sesame.street
bucket: ez9wo-apigee-backup-bucket
region: cookie
    6. Aggiorna i seguenti valori nel file apigee/helm_user_cluster/values-cookie-air-gapped.yaml: 
      objectstorekeyname: "apigee-backup-bucket-secret"
objectstoreurl: "BUCKET_ENDPOINT"
objectstorebucket: "BUCKET_FQDN"

      Dove:

      • BUCKET_ENDPOINT è l'endpoint del bucket ottenuto nel passaggio precedente.
      • BUCKET_FQDN è il nome di dominio completo del bucket ottenuto nel passaggio precedente.

    Configurare il nodo del repository

    In questo passaggio, l'operatore GDC configura un nodo del repository per ospitare il repository mirror di Apigee Edge for Private Cloud.

    Crea un nodo del repository

    Per creare un nodo del repository:

    1. Aggiorna apigee/helm_user_cluster/values-cookie-air-gapped.yaml come segue: 
      repo_node:
  enabled: true

apigee_node:
  enabled: false

control_node:
  enabled: false

      Assicurati che repo_node sia abilitato e che apigee_node e control_node siano disattivati. Il deployment di questi nodi viene eseguito in un passaggio successivo.

    2. Recupera le credenziali per il cluster di amministrazione dell'organizzazione: 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      dove ORG_ADMIN_CLUSTER è il nome del cluster GKE di amministrazione dell'organizzazione.

    3. Crea un ambiente virtuale Python: 
      python3 -m venv venv /
source venv/bin/activate
    4. Esegui lo script di deployment per creare il nodo del repository: 
      python apigee/solution_deploy.py gdc-air-gapped

    Configurare l'accesso al nodo del repository

    Per configurare l'accesso al nodo del repository:

    1. Configura SSH per il nodo del repository: 
      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

      dove SSH_PUBLIC_KEY_FILE è il nome del file contenente la chiave SSH pubblica.

    2. Ottieni l'indirizzo IP esterno del nodo del repository: 
      kubectl get virtualmachineexternalaccess -n $PROJECT $NODE -ojsonpath='{.status.ingressIP}'
    3. Ottieni l'indirizzo IP interno del nodo del repository: 
      kubectl get virtualmachines.virtualmachine.gdc.goog -n $PROJECT $NODE -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

    Carica i file di installazione

    In questo passaggio, l'operatore GDC carica la versione più recente dei seguenti file nel nodo del repository:

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

    Per caricare i file di installazione:

    1. Copia il file della chiave privata SSH nel nodo del repository: 
      scp -i SSH_PRIVATE_KEY_FILE ~/apigee-files/* admin@REPO_EXTERNAL_IP:/tmp

      Dove:

      • SSH_PRIVATE_KEY_FILE è il nome del file contenente la chiave SSH privata.
      • REPO_EXTERNAL_IP è l'indirizzo IP esterno del nodo del repository ottenuto nel passaggio precedente.
    2. Carica la cartella contenente le configurazioni di Fluent Bit nel nodo del repository: 
      scp -i SSH-PRIVATE-KEY-FILE -r apigee/scripts/fluent-bit admin@REPO_EXTERNAL_IP:/tmp/fluent-bit

      Dove:

      • SSH_PRIVATE_KEY_FILE è il nome del file contenente la chiave SSH privata.
      • REPO_EXTERNAL_IP è l'indirizzo IP esterno del nodo del repository.

    Configura il repository mirror

    Per configurare il repository mirror:

    1. Copia apigee/scripts/repo_setup.sh nel nodo del repository.
    2. Nello script, sostituisci REPO_USER e REPO_PASSWORD con il nome utente e la password che preferisci per il repository mirror.
    3. Esegui lo script: 
      chmod a+x repo_setup.sh
./repo_setup.sh

      Se si verifica un errore No such file or directory, esegui di nuovo lo script.

    4. Testa la connessione al repository mirror localmente dal nodo del repository. 
      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

      Sostituisci VERSION con la versione di Apigee Edge for Private Cloud che vuoi installare.

    Esegui il deployment dei nodi Apigee

    In questo passaggio, l'operatore GDC esegue il deployment dei nodi di gestione delle API Apigee.

    Crea nodi Apigee

    Per creare i nodi di gestione delle API Apigee:

    1. Sostituisci REPO_INTERNAL_IP, REPO_USER_NAME e REPO_PASSWORD in apigee/helm/scripts/apigee_setup.sh con i valori desiderati.
    2. Esporta i valori come variabili di ambiente: 
      export REPO_IP=REPO_INTERNAL_IP
export REPO_USER=REPO_USER_NAME
export REPO_PASSWORD=REPO_PASSWORD
    3. Attiva apigee_node in apigee/helm/values-cookie-air-gapped.yaml come mostrato: 
      apigee_node:
  enabled: true
    4. Esegui lo script di deployment per creare i nodi Apigee: 
        source venv/bin/activate
  python apigee/solution_deploy.py gdc-air-gapped

    Configurare l'accesso ai nodi Apigee

    Configura l'accesso ai nodi di gestione API Apigee:

    1. Esegui l'autenticazione sul cluster dell'amministratore dell'organizzazione: 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      dove ORG_ADMIN_CLUSTER è il nome del cluster GKE di amministrazione dell'organizzazione.

    2. Crea una chiave SSH per ogni 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

      dove SSH_PUBLIC_KEY_FILE è il nome del file contenente la chiave SSH pubblica.

    3. Ottieni gli indirizzi IP esterni per i nodi Apigee: 
      for i in 1 2 3 4 5; do
  kubectl get virtualmachineexternalaccess -n $PROJECT node$i -ojsonpath='{.status.ingressIP}'
  echo
  done
    4. Ottieni gli indirizzi IP interni per i nodi 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. (Facoltativo) Controlla se gli script di avvio vengono eseguiti correttamente sui nodi Apigee:
      1. Connettiti al nodo tramite SSH ed esegui il seguente comando: 
        sudo journalctl -u cloud-final -f
      2. Cerca log simili ai seguenti: 
        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

    Configurare il nodo di controllo

    In questo passaggio, l'operatore GDC configura un nodo di controllo per gestire le installazioni di Apigee.

    Crea un nodo di controllo

    Per creare un nodo di controllo:

    1. Sostituisci REPO_INTERNAL_IP, REPO_USER_NAME e REPO_PASSWORD in apigee/helm/scripts/control_setup.sh con i valori desiderati.
    2. Attiva control_node in apigee/helm/values-cookie-air-gapped.yaml come mostrato: 
      control_node:
  enabled: true
    3. Esegui lo script di deployment per creare il nodo di controllo: 
      source venv/bin/activate
python apigee/solution_deploy.py gdc-air-gapped

    Configurare l'accesso al nodo di controllo

    Per configurare l'accesso al nodo di controllo:

    1. Configura l'accesso SSH al nodo di controllo: 
      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. Ottieni l'indirizzo IP esterno per il nodo di controllo: 
      kubectl get virtualmachineexternalaccess -n $PROJECT control -ojsonpath='{.status.ingressIP}'
    3. Ottieni l'IP interno del nodo di controllo: 
      kubectl get virtualmachines.virtualmachine.GDC.goog -n $PROJECT control -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

    Configura Ansible

    In questo passaggio, l'operatore GDC configura l'ambiente sul nodo di controllo.

    Per configurare l'ambiente Ansible:

    1. Accedi tramite SSH al nodo di controllo e configura l'ambiente Ansible: 
      cd /home/admin
cp -r /tmp/apigee-repos .
cd apigee-repos/ansible-opdk-accelerator/setup
    2. Sostituisci i repository Git remoti con il file locale: 
      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. Aggiorna la configurazione della configurazione:
      1. Modifica il file main.yml: 
        vi ~/apigee-repos/ansible-opdk-accelerator/setup/roles/apigee-opdk-setup-ansible-controller/tasks/main.yml
      2. Rimuovi le attività che richiedono l'accesso a GitHub:
        • Estrazione SSH Git dei repository di configurazione
        • Checkout HTTPS di Git dei repository di configurazione
      3. Esegui il playbook di configurazione: 
        cd ~/apigee-repos/ansible-opdk-accelerator/setup
ansible-playbook setup.yml
    5. Carica la chiave SSH per i nodi Apigee nel nodo di controllo: 
      scp -i CONTROL_SSH_PRIVATE_KEY_FILE APIGEE_NODE_SSH_PRIVATE_KEY_FILE admin@CONTROL_EXTERNAL_IP:/home/admin/.ssh/id_rsa

      Dove:

      • CONTROL_SSH_PRIVATE_KEY_FILE è il nome del file contenente la chiave privata SSH del nodo di controllo.
      • APIGEE_NODE_SSH_PRIVATE_KEY_FILE è il nome del file contenente la chiave privata SSH del nodo Apigee.
      • CONTROL_EXTERNAL_IP è l'indirizzo IP esterno del nodo di controllo.
    6. Crea il file di configurazione dell'inventario Ansible:
      1. Copia il contenuto del file apigee/scripts/ansible/prod.cfg nel file prod.cfg: 
        vi ~/.ansible/multi-planet-configurations/prod.cfg
      2. Crea la cartella edge-dc1 e copia i contenuti del file apigee/scripts/ansible/edge-dc1 nel file edge-dc1: 
        mkdir ~/.ansible/inventory/prod
vi ~/.ansible/inventory/prod/edge-dc1
    7. Aggiorna gli indirizzi IP interni dei nodi Apigee in 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

      Dove i valori di APIGEE_NODE*_INTERNAL_IP sono gli indirizzi IP interni dei nodi Apigee ottenuti in un passaggio precedente.

    8. Configura il file ~/.apigee-secure/credentials.yml con i seguenti valori:
      • 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'

      Dove:

      • APIGEE_REPO_USER è il nome utente per il repository Apigee.
      • APIGEE_REPO_PASSWORD è la password per il repository Apigee.
      • OPDK_QPID_MGMT_USERNAME è il nome utente del server di gestione Apigee QPID.
      • OPDK_QPID_MGMT_PASSWORD è la password per il server di gestione Apigee QPID.

    9. Aggiungi un file di licenza valido per Apigee Edge for Private Cloud. Il nome del file deve essere license.txt.
    10. Copia i contenuti del file ~/.apigee-secure/license.txt nel file license.txt appena creato.
    11. Configura i seguenti valori nel file ~/.apigee/custom-properties.yml:
      • opdk_version: 'OPDK_VERSION'
      • apigee_repo_url: 'APIGEE_REPO_URL'

      Dove:

      • OPDK_VERSION è la versione di Apigee Edge for Private Cloud che vuoi installare.
      • APIGEE_REPO_URL è l'URL del repository Apigee.

    12. Esporta il file di configurazione come variabile di ambiente: 
      export ANSIBLE_CONFIG=~/.ansible/multi-planet-configurations/prod.cfg

    Installa i componenti Apigee

    In questo passaggio, l'operatore GDC installa i componenti Apigee utilizzando Ansible.

    Per installare i componenti Apigee:

    1. Sostituisci i repository Git remoti con i file locali: 
      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. Installa i requisiti di Ansible: 
      ansible-galaxy install -r requirements.yml -f
    3. Applica le patch ai ruoli 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. Sostituisci i contenuti del file install.yml con i contenuti di apigee/scripts/ansible/install.yml.
    5. Esegui il playbook per installare i componenti Apigee: 
      ansible-playbook install.yml
    6. Disattiva il link di reimpostazione della password dell'utente nella UI Edge. Apigee su GDC con air gap non include un server SMTP. Segui i passaggi descritti in Disattivare il link di reimpostazione della password nell' interfaccia utente di Edge.

    Esegui il deployment di pod e servizi

    In questo passaggio, implementerai i pod e i servizi di caricamento, proxy inverso, bilanciatore del carico e logging.

    Per eseguire il deployment dei pod e dei servizi:

    1. Segui le istruzioni riportate in Creare istanze del registro Harbor per creare un'istanza Harbor nel progetto GDC dev-apigee.
    2. Segui le istruzioni riportate in Crea progetti Harbor per creare un progetto Harbor denominato apigee.
    3. Segui le istruzioni riportate in Configura il controllo dell'accesso per configurare il controllo dell'accesso per il progetto Harbor.
    4. Segui le istruzioni riportate in Accedere a Docker e Helm per configurare l'autenticazione Docker.
    5. Aggiorna gli indirizzi IP nel file apigee/apigee_user_cluster.toml come mostrato di seguito: 
      mgmt-server-proxy = "APIGEE_NODE1_EXTERNAL_IP"
router-proxy1 = "APIGEE_NODE2_EXTERNAL_IP"
router-proxy2 = "APIGEE_NODE3_EXTERNAL_IP"

      Dove:

      • APIGEE_NODE1_EXTERNAL_IP è l'indirizzo IP esterno del nodo Apigee 1 ottenuto in un passaggio precedente.
      • APIGEE_NODE2_EXTERNAL_IP è l'indirizzo IP esterno del nodo Apigee2 ottenuto in un passaggio precedente.
      • APIGEE_NODE3_EXTERNAL_IP è l'indirizzo IP esterno del nodo Apigee3 ottenuto in un passaggio precedente.

    6. Posiziona il file del certificato SSL (server.crt) e il file della chiave (server.key) per la configurazione di HTTPS nelle cartelle apigee/mgmt-server-proxy e apigee/router-proxy.

      Per generare certificati autofirmati, utilizza il seguente comando: 

      openssl req -newkey rsa:4096 -x509 -nodes -keyout server.key -new -out server.crt -subj "/CN=*.apigeetest.com" -sha256 -days 365
    7. Aggiorna il valore di SSH-PASSWORD per l'utente root nel contenitore di caricamento nel file apigee/uploader/Dockerfile: 
      RUN echo 'root:SSH_PASSWORD' | chpasswd
    8. Recupera le credenziali per il cluster utente: 
      gdcloud clusters get-credentials USER_CLUSTER

      dove USER_CLUSTER è il nome del cluster GKE dell'utente.

    9. Esegui lo script di deployment per eseguire il deployment dei pod e dei servizi: 
      source venv/bin/activate
python apigee/solution_deploy_user_cluster.py gdc-air-gapped
    10. Recupera gli indirizzi IP esterni dei servizi: 
      kubectl get svc -n $PROJECT_ID

    Aggiorna gli IP di caricamento e di inoltro di Fluent Bit

    In questo passaggio, aggiornerai gli indirizzi IP dell'uploader e del forwarder Fluent Bit negli script di backup e configurazione di Apigee.

    1. Aggiorna SSH_PASSWORD, root e UPLOADER_EXTERNAL_IP in 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/

      Dove:

      • SSH_PASSWORD è la password per l'utente root.
      • UPLOADER_EXTERNAL_IP è l'indirizzo IP esterno del servizio di caricamento ottenuto in un passaggio precedente.

    2. Aggiornamento di FLUENTBIT_EXTERNAL_IP in apigee/helm/scripts/apigee_setup.sh: 
      export FLUENTBIT_EXTERNAL_IP=FLUENTBIT_EXTERNAL_IP

    L'aggiornamento dello script di avvio richiede il riavvio dei nodi Apigee. Per riavviare i nodi:

    1. Arresta le VM: 
      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. Esegui nuovamente il deployment del grafico Helm: 
      python apigee/solution_deploy.py gdc-air-gapped
    3. Avvia le VM: 
      for i in 1 2 3 4 5; do
  GDCloud compute instances start node$i --project $PROJECT
  done

    Esegui l'onboarding dell'organizzazione Apigee

    In questo passaggio, l'operatore GDC esegue l'onboarding dell'organizzazione Apigee eseguendo uno script di configurazione su node1.

    Per eseguire l'onboarding dell'organizzazione Apigee:

    1. Aggiorna i seguenti valori in apigee/scripts/apigee_org_setup.sh come mostrato. Aggiorna gli altri parametri in base alle esigenze. 
      IP1=APIGEE_NODE1_INTERNAL_IP

VHOST_ALIAS="APIGEE_NODE2_EXTERNAL_IP:9001 APIGEE_NODE3_EXTERNAL_IP:9001"

      Dove:

      • APIGEE_NODE1_INTERNAL_IP è l'indirizzo IP interno del nodo Apigee 1 ottenuto in un passaggio precedente.
      • APIGEE_NODE2_EXTERNAL_IP è l'indirizzo IP esterno del nodo Apigee2 ottenuto in un passaggio precedente.
      • APIGEE_NODE3_EXTERNAL_IP è l'indirizzo IP esterno del nodo Apigee3 ottenuto in un passaggio precedente.

    2. Esegui lo script su node1 per eseguire l'onboarding dell'organizzazione: 
      chmod a+x apigee_org_setup.sh
./apigee_org_setup.sh

    Verifica la connettività HTTP

    In questo passaggio, testerai la connettività HTTP per l'API Management e il proxy API.

    Per testare la connettività HTTP:

    1. Ottieni l'indirizzo IP esterno del servizio apigee-elb: 
      gdcloud clusters get-credentials USER_CLUSTER
export PROJECT=dev-apigee
kubectl get svc apigee-elb -n $PROJECT

      dove USER_CLUSTER è il nome del cluster GKE dell'utente.

      Questo servizio funge da endpoint per la UI Edge, l'API Management e il proxy API.

    Testare l'API Management

    Per testare l'API Management, invia una richiesta HTTP all'endpoint: 

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

    Dove:

    • APIGEE_ELB_EXTERNAL_IP è l'indirizzo IP esterno del servizio apigee-elb ottenuto in un passaggio precedente.
    • ORG_NAME è il nome dell'organizzazione Apigee.
    • ENV_NAME è il nome dell'ambiente Apigee.

    Testa il proxy API

    Per testare il proxy API:

    1. Accedi all'interfaccia utente di Edge.
    2. Nella pagina Proxy API, fai clic su Crea per creare un nuovo proxy API.
    3. Nella pagina Dettagli proxy, inserisci i seguenti valori:
      • Tipo di proxy:seleziona Nessun target.
      • Nome proxy: ok
      • Base path: /ok
      • Target: http://APIGEE_ELB_EXTERNAL_IP:9001
    4. Fai clic su Crea per creare il proxy API.
    5. Invia una richiesta HTTP a /ok: 
      curl -i http://APIGEE_ELB_EXTERNAL_IP:9001/ok
    6. Conferma che la risposta sia 200 OK.

    Configura TLS e testa HTTPS

    In questo passaggio, l'operatore GDC configura Transport Layer Security (TLS) per il proxy API, la UI Edge e l'API Management.

    Configura TLS per il proxy API

    1. Segui i passaggi descritti in Creare un keystore/truststore e un alias per creare un certificato autofirmato con i seguenti valori:
      • KeyStore: myTestKeystore
      • KeyAlias: myKeyAlias
      • Nome comune: apigeetest.com
    2. Esegui una chiamata API per creare l'host virtuale denominato 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>'

      Dove:

      • APIGEE_ELB_EXTERNAL_IP è l'indirizzo IP esterno del servizio apigee-elb ottenuto in un passaggio precedente.
      • ORG_NAME è il nome dell'organizzazione Apigee.
      • ENV_NAME è il nome dell'ambiente Apigee in cui deve essere creato l'host virtuale.
    3. Crea un proxy API utilizzando l'host virtuale sicuro.
    4. Sui router, configura la risoluzione DNS per gli host virtuali: 
      echo '127.0.0.1 api.apigeetest.com' | sudo tee -a /etc/hosts
    5. Verifica che gli host virtuali funzionino localmente inviando una richiesta HTTPS all'endpoint: 
      curl https://api.apigeetest.com:9005/ok -v -k
    6. Configura la risoluzione DNS per l'endpoint: 
      echo 'APIGEE_ELB_EXTERNAL_IP apigeetest.com' | sudo tee -a /etc/hosts

      dove APIGEE_ELB_EXTERNAL_IP è l'indirizzo IP esterno del servizio apigee-elb ottenuto in un passaggio precedente.

    7. Vai alla pagina https://apigeetest.com/ok in un browser web e verifica che funzioni.

    Configurare TLS per la UI Edge

    Per configurare TLS per la UI Edge:

    1. Genera un file keystore dal file del certificato SSL e dal file della chiave: 
      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. Posiziona il file del keystore nella cartella Apigee su node1: 
      scp -i SSH_PRIVATE_KEY_FILE keystore.jks admin@APIGEE_NODE1_EXTERNAL_IP:/home/admin/

      Dove:

      • SSH_PRIVATE_KEY_FILE è il nome del file contenente la chiave privata SSH del nodo Apigee.
      • APIGEE_NODE1_EXTERNAL_IP è l'indirizzo IP esterno del nodo Apigee 1 ottenuto in un passaggio precedente.

    3. Esegui SSH su node1 e sposta il file del keystore nella cartella Apigee: 
      sudo mv keystore.jks /opt/apigee/customer/application/
    4. Crea il file di configurazione SSL: 
      sudo vi /tmp/sslConfigFile
    5. Aggiorna il valore di KEY-PASS-PHRASE come mostrato: 
      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 utilizzando il file di configurazione: 
      sudo chown apigee:apigee /tmp/sslConfigFile
/opt/apigee/apigee-service/bin/apigee-service edge-ui configure-ssl -f /tmp/sslConfigFile
    7. Configura la risoluzione DNS per la UI Edge: 
      echo 'APIGEE_ELB_EXTERNAL_IP ui.apigeetest.com' | sudo tee -a /etc/hosts

      dove APIGEE_ELB_EXTERNAL_IP è l'indirizzo IP esterno del servizio apigee-elb ottenuto in un passaggio precedente.

    8. Accedi a https://ui.apigeetest.com:9443 in un browser web e verifica che funzioni. Per maggiori dettagli, consulta la guida.

    Configurare TLS per l'API Management

    Per configurare TLS per l'API Management:

    1. Configura il proprietario del file dell'archivio chiavi (utilizza lo stesso dell'interfaccia utente Edge): 
      sudo chown apigee:apigee /opt/apigee/customer/application/keystore.jks
    2. Crea il file delle proprietà: 
      sudo vi /opt/apigee/customer/application/management-server.properties

      3. Sostituisci il valore di KEY_PASS_PHRASE con la password del keystore, come mostrato: 

      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. Riavvia il server di gestione per applicare le modifiche: 
      /opt/apigee/apigee-service/bin/apigee-service edge-management-server restart
    4. Verifica che HTTPS funzioni localmente: 
      curl -u "opdk@apigee.com:Apigee123!" "https://localhost:8443/v1/users" -k
    5. Dal client, accedi a https://apigeetest.com:8443/v1/users nel browser. Inserisci il nome utente e la password dell'amministratore per confermare che le credenziali siano configurate correttamente.

    Passaggi successivi