Installer Apigee sur Google Distributed Cloud sous air gap

Ce guide explique comment installer et déployer Apigee Edge pour le cloud privé et les proxys d'API dans un environnement Google Distributed Cloud (GDC) isolé. Les offres GDC avec air gap, y compris Apigee Edge pour le cloud privé, ne nécessitent pas de connectivité à Google Cloud pour gérer l'infrastructure et les services. Vous pouvez utiliser un plan de contrôle local hébergé sur vos serveurs pour toutes les opérations. Pour obtenir une présentation de GDC sous air gap, consultez la présentation.

Ce guide est destiné aux opérateurs Apigee qui connaissent Apigee Edge pour le cloud privé et qui ont des connaissances de base sur Kubernetes.

Présentation des étapes requises

Pour installer et déployer Apigee Edge pour Private Cloud dans un environnement GDC isolé, l'opérateur doit procéder comme suit :

Avant de commencer

Avant de commencer le processus d'installation, veillez à effectuer les étapes suivantes :

  1. Créez un projet GDC à utiliser pour l'installation, si vous n'en avez pas déjà un. Pour en savoir plus, consultez Créer un projet.
  2. Téléchargez, installez et configurez la CLI gdcloud sur un poste de travail connecté à GDC ou dans l'environnement de déploiement continu de votre organisation.
  3. Obtenez les identifiants requis pour utiliser la CLI gdcloud et l'API kubectl. Consultez Authentifier votre compte pour y accéder pour connaître la procédure à suivre.
  4. Confirmez le nom d'utilisateur et le mot de passe Apigee que vous avez reçus de votre responsable de compte Apigee.
  5. Confirmez le nom de votre cluster d'administrateur GKE et de votre cluster d'utilisateur GKE.

Besoins en capacité

L'installation d'Apigee Edge pour le cloud privé sur GDC nécessite plusieurs machines virtuelles (VM) avec des allocations de ressources spécifiques. Ces VM entraînent des frais en fonction de leurs ressources de calcul (RAM, cœurs de processeur virtuel) et de leur stockage sur disque local. Pour en savoir plus, consultez la page Tarifs.

Le tableau suivant indique les exigences en termes de ressources pour chaque VM :

Type de VM RAM Cœurs du processeur virtuel Stockage sur disque
Nœud de dépôt 8 Go 2 cœurs de processeur virtuel 64 Go
Nœud de contrôle 8 Go 2 cœurs de processeur virtuel 64 Go
Nœuds de gestion des API Apigee 1, 2 et 3 16 Go de RAM 8 cœurs de processeur virtuel 670 Go
Nœuds de gestion des API Apigee 4 et 5 16 Go de RAM 8 cœurs de processeur virtuel 500 Go à 1 To

Rôles et autorisations

Les rôles et autorisations suivants sont requis pour déployer Apigee Edge pour le cloud privé dans un environnement GDC isolé :

  • Administrateur de plate-forme : attribuez le rôle IAM Admin.
  • Opérateur d'application : attribuez les rôles suivants :
    • Harbor Instance Admin : dispose d'un accès complet pour gérer les instances Harbor dans un projet.
    • LoggingTarget Creator : crée des ressources personnalisées LoggingTarget dans l'espace de noms du projet.
    • LoggingTarget Editor : modifie les ressources personnalisées LoggingTarget dans l'espace de noms du projet.
    • Project Bucket Admin : gère les buckets de stockage et les objets qu'ils contiennent.
    • Project Grafana Viewer : accède à l'instance de surveillance dans l'espace de noms du projet.
    • Project NetworkPolicy Admin : gère les règles réseau du projet dans l'espace de noms du projet.
    • Project VirtualMachine Admin : gère les machines virtuelles dans l'espace de noms du projet.
    • Secret Admin : gère les secrets Kubernetes dans les projets.
    • Service Configuration Admin : dispose d'un accès en lecture et en écriture aux configurations de service dans un espace de noms de projet.
    • Namespace Admin : gère toutes les ressources dans les espaces de noms du projet.

    • Pour en savoir plus sur l'attribution de rôles et d'autorisations GDC en mode air-gap, consultez Accorder et révoquer l'accès.

    Limites

    Les limites suivantes s'appliquent à Apigee sur GDC air-gapped :

    • Apigee sur GDC air-gapped n'est pas fourni avec des serveurs DNS et utilise la résolution DNS locale comme solution de contournement. Si Apigee sur GDC air-gapped est déployé dans un environnement avec des serveurs DNS externes, remplacez les étapes qui configurent le DNS local par la configuration des entrées DNS dans les serveurs DNS.
    • Apigee sur GDC air-gapped n'inclut pas de serveur SMTP autonome. Vous pouvez configurer un serveur SMTP à tout moment pour activer les notifications par e-mail sortantes pour la création de comptes et la réinitialisation de mots de passe à partir du serveur de gestion et de l'interface utilisateur de gestion. Les API de gestion restent disponibles pour la gestion des comptes utilisateur Apigee. Pour en savoir plus, consultez Configurer le serveur SMTP Edge.
    • Apigee sur GDC sous air gap n'implémente pas la détection et la prévention des intrusions. Installez et configurez un système de prévention des intrusions (IPS), tel que Snort, pour détecter et prévenir les activités malveillantes.

    Obtenir les fichiers requis

    Pour obtenir les fichiers d'installation, vous devez d'abord configurer un nœud connecté, puis télécharger les fichiers.

    Configurer un nœud connecté

    Le nœud connecté est une seule VM en dehors de GDC que vous utilisez pour télécharger les fichiers d'installation. Cette VM nécessite un accès à Internet et n'est utilisée que pour le processus d'installation.

    Le nœud connecté nécessite la capacité et la configuration suivantes :

    • Système d'exploitation : Rocky Linux 8
    • Taille de la machine : 8 Go de RAM, 2 cœurs de processeur virtuel, 64 Go de stockage sur disque local
    • Connectivité :
      • Entrée : TCP 22 (SSH)
      • Sortie : Internet

    Pour créer le nœud connecté, suivez les instructions de la section Créer et démarrer une instance de VM. Une fois la VM créée, suivez les instructions de la section Se connecter à des VM Linux. pour vous connecter à la VM. Pour obtenir la liste des systèmes d'exploitation compatibles, consultez Systèmes d'exploitation compatibles avec GDC.

    Télécharger les fichiers d'installation

    Pour télécharger les fichiers d'installation :

    1. Consultez les notes de version d'Apigee Edge for Private Cloud pour connaître la dernière version officielle compatible avec GDC, comme indiqué dans la colonne "Edge for Private Cloud".
    2. Téléchargez le fichier d'installation d'Edge : 
      curl https://software.apigee.com/apigee/tarball/VERSION/rocky8/archive.tar -o /tmp/archive.tar -u 'APIGEE_USER:APIGEE_PASSWORD'

      Où :

      • APIGEE_USER est le nom d'utilisateur que vous avez reçu pour l'organisation Apigee.
      • APIGEE_PASSWORD est le mot de passe que vous avez reçu pour l'organisation Apigee.
      • VERSION correspond à la version d'Apigee Edge pour le cloud privé à utiliser sur GDC que vous souhaitez installer, par exemple 4.53.01.
    3. Téléchargez le dernier fichier bootstrap_VERSION.sh d'Apigee Edge pour le cloud privé sur /tmp/bootstrap_VERSION.sh : 
      curl https://software.apigee.com/bootstrap_VERSION.sh -o /tmp/bootstrap_VERSION.sh

      Où VERSION correspond à la dernière version d'Apigee Edge pour le cloud privé à utiliser sur GDC que vous souhaitez installer, par exemple 4.53.01.

    4. Installez l'utilitaire apigee-service Edge et les dépendances : 
      sudo bash /tmp/bootstrap_VERSION.sh apigeeuser=APIGEE_USER apigeepassword=APIGEE_PASSWORD

      Où :

      • APIGEE_USER est le nom d'utilisateur que vous avez reçu pour l'organisation Apigee.
      • APIGEE_PASSWORD est le mot de passe que vous avez reçu pour l'organisation Apigee.
      • VERSION correspond à la version d'Apigee Edge pour le cloud privé à utiliser sur GDC que vous souhaitez installer.

    5. Exécutez le script d'installation sur le nœud connecté : 
      chmod a+x connected-node_setup.sh \
  ./connected-node_setup.sh

      À cette étape, le script génère les fichiers requis aux emplacements suivants (par exemple, pour la version 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. Transférez les fichiers requis du nœud connecté vers une machine locale via 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

      Où :

      • SSH_PRIVATE_KEY_FILE correspond au chemin d'accès au fichier de clé privée SSH.
      • USER est le nom d'utilisateur du nœud connecté.
      • CONNECTED_NODE_IP est l'adresse IP du nœud connecté.

    Configurer le bucket de stockage

    Au cours de cette étape, l'opérateur GDC configure un bucket de stockage dans le projet GDC pour stocker les fichiers de sauvegarde Apigee Edge pour le cloud privé.

    Créer un bucket de stockage

    Pour créer un bucket de stockage dans le projet GDC :

    1. Authentifiez-vous auprès du cluster d'administrateur de l'organisation : 
      gdcloud auth login --login-config-cert WEB_TLS_CERT
gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      Où :

      • WEB_TLS_CERT correspond au chemin d'accès au certificat TLS Web.
      • ORG_ADMIN_CLUSTER correspond au nom du cluster GKE de l'administrateur de l'organisation.

    2. Définissez les variables d'environnement pour le projet et le bucket : 
      export PROJECT=PROJECT
export BUCKET=BUCKET_NAME

      Où :

      • PROJECT est le nom de votre projet GDC.
      • BUCKET_NAME correspond au nom du bucket que vous souhaitez créer pour stocker les fichiers de sauvegarde Apigee Edge pour Private Cloud.
    3. Appliquez la configuration du 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

      Cette configuration crée un bucket avec une période de conservation de 30 jours.

    Configurer l'accès aux buckets

    Pour configurer l'accès au bucket de stockage :

    1. Créez un compte de service dans le projet : 
      gdcloud iam service-accounts create $BUCKET-sa \
    --project=$PROJECT
    2. Créez le rôle et la liaison de rôle pour générer un secret permettant d'accéder au 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. Obtenez l'ID et la clé d'accès à partir du 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']}")"

      Le résultat doit ressembler à ce qui suit : 

      access-key-id=RFdJMzRROVdWWjFYNTJFTzJaTk0=
access-key=U3dSdm5FRU5WdDhMckRMRW1QRGV0bE9MRHpCZ0Ntc0cxVFJQdktqdg==
    4. Créez un secret à utiliser par le programme d'importation dans le cluster GKE de l'utilisateur :
      1. Authentifiez-vous auprès du cluster d'utilisateur GKE : 
        gdcloud clusters get-credentials USER_CLUSTER

        où USER_CLUSTER est le nom du cluster GKE utilisateur.

      2. Appliquez la configuration du 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

        Où :

        • ACCESS_KEY_ID correspond à l'ID de clé d'accès obtenu à l'étape précédente.
        • ACCESS_KEY correspond à la clé d'accès obtenue à l'étape précédente.
    5. Obtenez le point de terminaison de stockage, le nom de domaine complet et la région du bucket :
      1. Authentifiez-vous auprès du cluster d'administrateur de l'organisation : 
        gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

        où ORG_ADMIN_CLUSTER est le nom du cluster GKE de l'administrateur de l'organisation.

      2. Obtenez le point de terminaison de stockage, le nom de domaine complet et la région du bucket : 
        kubectl get buckets ${BUCKET} -n $PROJECT -o jsonpath="{'endpoint: '}{.status.endpoint}{'\n'}{'bucket: '}{.status.fullyQualifiedName}{'\n'}{'region: '}{.status.region}{'\n'}"

        Le résultat doit ressembler à ce qui suit :

        endpoint: https://objectstorage.gpu-org.cookie.sesame.street
bucket: ez9wo-apigee-backup-bucket
region: cookie
    6. Mettez à jour les valeurs suivantes dans le fichier apigee/helm_user_cluster/values-cookie-air-gapped.yaml : 
      objectstorekeyname: "apigee-backup-bucket-secret"
objectstoreurl: "BUCKET_ENDPOINT"
objectstorebucket: "BUCKET_FQDN"

      Où :

      • BUCKET_ENDPOINT correspond au point de terminaison du bucket obtenu à l'étape précédente.
      • BUCKET_FQDN correspond au nom de domaine complet du bucket obtenu à l'étape précédente.

    Configurer le nœud de dépôt

    Dans cette étape, l'opérateur GDC configure un nœud de dépôt pour héberger le dépôt miroir Apigee Edge pour le cloud privé.

    Créer un nœud de dépôt

    Pour créer un nœud de dépôt :

    1. Mettez à jour apigee/helm_user_cluster/values-cookie-air-gapped.yaml comme indiqué ci-dessous : 
      repo_node:
  enabled: true

apigee_node:
  enabled: false

control_node:
  enabled: false

      Assurez-vous que repo_node est activé et que apigee_node et control_node sont désactivés. Ces nœuds seront déployés ultérieurement.

    2. Obtenez les identifiants du cluster d'administrateur de l'organisation : 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      où ORG_ADMIN_CLUSTER est le nom du cluster GKE de l'administrateur de l'organisation.

    3. Créez un environnement virtuel Python : 
      python3 -m venv venv /
source venv/bin/activate
    4. Exécutez le script de déploiement pour créer le nœud de dépôt : 
      python apigee/solution_deploy.py gdc-air-gapped

    Configurer l'accès aux nœuds du dépôt

    Pour configurer l'accès au nœud de dépôt :

    1. Configurez SSH pour le nœud du dépôt : 
      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

      Où SSH_PUBLIC_KEY_FILE est le nom du fichier contenant votre clé SSH publique.

    2. Récupérez l'adresse IP externe du nœud de dépôt : 
      kubectl get virtualmachineexternalaccess -n $PROJECT $NODE -ojsonpath='{.status.ingressIP}'
    3. Obtenez l'adresse IP interne du nœud de dépôt : 
      kubectl get virtualmachines.virtualmachine.gdc.goog -n $PROJECT $NODE -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

    Importer des fichiers d'installation

    Lors de cette étape, l'opérateur GDC importe la dernière version des fichiers suivants dans le nœud de dépôt :

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

    Pour importer les fichiers d'installation :

    1. Copiez le fichier de clé privée SSH sur le nœud du dépôt : 
      scp -i SSH_PRIVATE_KEY_FILE ~/apigee-files/* admin@REPO_EXTERNAL_IP:/tmp

      Où :

      • SSH_PRIVATE_KEY_FILE est le nom du fichier contenant votre clé SSH privée.
      • REPO_EXTERNAL_IP correspond à l'adresse IP externe du nœud de dépôt obtenue à l'étape précédente.
    2. Importez le dossier contenant les configurations Fluent Bit dans le nœud du dépôt : 
      scp -i SSH-PRIVATE-KEY-FILE -r apigee/scripts/fluent-bit admin@REPO_EXTERNAL_IP:/tmp/fluent-bit

      Où :

      • SSH_PRIVATE_KEY_FILE est le nom du fichier contenant votre clé SSH privée.
      • REPO_EXTERNAL_IP est l'adresse IP externe du nœud de dépôt.

    Configurer le dépôt miroir

    Pour configurer le dépôt miroir :

    1. Copiez apigee/scripts/repo_setup.sh sur le nœud du dépôt.
    2. Dans le script, remplacez REPO_USER et REPO_PASSWORD par le nom d'utilisateur et le mot de passe souhaités pour le dépôt miroir.
    3. Exécutez le script : 
      chmod a+x repo_setup.sh
./repo_setup.sh

      Si vous rencontrez une erreur No such file or directory, réexécutez le script.

    4. Testez la connexion au dépôt miroir localement à partir du nœud du dépôt. 
      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

      Remplacez VERSION par la version d'Apigee Edge pour le cloud privé que vous souhaitez installer.

    Déployer des nœuds Apigee

    Lors de cette étape, l'opérateur GDC déploie les nœuds de gestion des API Apigee.

    Créer des nœuds Apigee

    Pour créer les nœuds de gestion de l'API Apigee :

    1. Remplacez REPO_INTERNAL_IP, REPO_USER_NAME et REPO_PASSWORD dans apigee/helm/scripts/apigee_setup.sh par les valeurs souhaitées.
    2. Exportez les valeurs en tant que variables d'environnement : 
      export REPO_IP=REPO_INTERNAL_IP
export REPO_USER=REPO_USER_NAME
export REPO_PASSWORD=REPO_PASSWORD
    3. Activez apigee_node dans apigee/helm/values-cookie-air-gapped.yaml comme indiqué : 
      apigee_node:
  enabled: true
    4. Exécutez le script de déploiement pour créer les nœuds Apigee : 
        source venv/bin/activate
  python apigee/solution_deploy.py gdc-air-gapped

    Configurer l'accès aux nœuds Apigee

    Configurez l'accès aux nœuds de gestion de l'API Apigee :

    1. Authentifiez-vous auprès du cluster d'administrateur de l'organisation : 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      où ORG_ADMIN_CLUSTER est le nom du cluster GKE de l'administrateur de l'organisation.

    2. Créez une clé SSH pour chaque nœud : 
      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

      Où SSH_PUBLIC_KEY_FILE est le nom du fichier contenant votre clé SSH publique.

    3. Récupérez les adresses IP externes des nœuds Apigee : 
      for i in 1 2 3 4 5; do
  kubectl get virtualmachineexternalaccess -n $PROJECT node$i -ojsonpath='{.status.ingressIP}'
  echo
  done
    4. Obtenez les adresses IP internes des nœuds 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. (Facultatif) Vérifiez si les scripts de démarrage s'exécutent correctement sur les nœuds Apigee :
      1. Connectez-vous au nœud en SSH et exécutez la commande suivante : 
        sudo journalctl -u cloud-final -f
      2. Recherchez des journaux semblables à ceux-ci : 
        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

    Configurer le nœud de contrôle

    Dans cette étape, l'opérateur GDC configure un nœud de contrôle pour gérer les installations Apigee.

    Créer un nœud de contrôle

    Pour créer un nœud de contrôle :

    1. Remplacez REPO_INTERNAL_IP, REPO_USER_NAME et REPO_PASSWORD dans apigee/helm/scripts/control_setup.sh par les valeurs souhaitées.
    2. Activez control_node dans apigee/helm/values-cookie-air-gapped.yaml comme indiqué : 
      control_node:
  enabled: true
    3. Exécutez le script de déploiement pour créer le nœud de contrôle : 
      source venv/bin/activate
python apigee/solution_deploy.py gdc-air-gapped

    Configurer l'accès au nœud de contrôle

    Pour configurer l'accès au nœud de contrôle :

    1. Configurez l'accès SSH au nœud de contrôle : 
      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. Récupérez l'adresse IP externe du nœud de contrôle : 
      kubectl get virtualmachineexternalaccess -n $PROJECT control -ojsonpath='{.status.ingressIP}'
    3. Obtenez l'adresse IP interne du nœud de contrôle : 
      kubectl get virtualmachines.virtualmachine.GDC.goog -n $PROJECT control -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

    Configurer Ansible

    Au cours de cette étape, l'opérateur GDC configure l'environnement sur le nœud de contrôle.

    Pour configurer l'environnement Ansible :

    1. Connectez-vous en SSH au nœud de contrôle et configurez l'environnement Ansible : 
      cd /home/admin
cp -r /tmp/apigee-repos .
cd apigee-repos/ansible-opdk-accelerator/setup
    2. Remplacer les dépôts Git distants par un fichier 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. Mettez à jour la configuration :
      1. Modifiez le fichier main.yml comme suit : 
        vi ~/apigee-repos/ansible-opdk-accelerator/setup/roles/apigee-opdk-setup-ansible-controller/tasks/main.yml
      2. Supprimez les tâches qui nécessitent un accès GitHub :
        • Extraction SSH Git des dépôts de configuration
        • Extraction HTTPS Git des dépôts de configuration
      3. Exécutez le playbook de configuration : 
        cd ~/apigee-repos/ansible-opdk-accelerator/setup
ansible-playbook setup.yml
    5. Importez la clé SSH pour les nœuds Apigee vers le nœud de contrôle : 
      scp -i CONTROL_SSH_PRIVATE_KEY_FILE APIGEE_NODE_SSH_PRIVATE_KEY_FILE admin@CONTROL_EXTERNAL_IP:/home/admin/.ssh/id_rsa

      Où :

      • CONTROL_SSH_PRIVATE_KEY_FILE est le nom du fichier contenant la clé privée SSH de votre nœud de contrôle.
      • APIGEE_NODE_SSH_PRIVATE_KEY_FILE est le nom du fichier contenant la clé privée SSH de votre nœud Apigee.
      • CONTROL_EXTERNAL_IP est l'adresse IP externe du nœud de contrôle.
    6. Créez le fichier de configuration de l'inventaire Ansible :
      1. Copiez le contenu du fichier apigee/scripts/ansible/prod.cfg dans le fichier prod.cfg : 
        vi ~/.ansible/multi-planet-configurations/prod.cfg
      2. Créez le dossier edge-dc1 et copiez le contenu du fichier apigee/scripts/ansible/edge-dc1 dans le fichier edge-dc1 : 
        mkdir ~/.ansible/inventory/prod
vi ~/.ansible/inventory/prod/edge-dc1
    7. Mettez à jour les adresses IP internes des nœuds Apigee dans 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

      Où les valeurs de APIGEE_NODE*_INTERNAL_IP sont les adresses IP internes des nœuds Apigee obtenues lors d'une étape précédente.

    8. Configurez le fichier ~/.apigee-secure/credentials.yml avec les valeurs suivantes :
      • 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'

      Où :

      • APIGEE_REPO_USER est le nom d'utilisateur du dépôt Apigee.
      • APIGEE_REPO_PASSWORD est le mot de passe du dépôt Apigee.
      • OPDK_QPID_MGMT_USERNAME est le nom d'utilisateur du serveur de gestion Apigee QPID.
      • OPDK_QPID_MGMT_PASSWORD correspond au mot de passe du serveur de gestion Apigee QPID.

    9. Ajoutez un fichier de licence Apigee Edge for Private Cloud valide. Le nom du fichier doit être license.txt.
    10. Copiez le contenu du fichier ~/.apigee-secure/license.txt dans le fichier license.txt que vous venez de créer.
    11. Configurez les valeurs suivantes dans le fichier ~/.apigee/custom-properties.yml :
      • opdk_version: 'OPDK_VERSION'
      • apigee_repo_url: 'APIGEE_REPO_URL'

      Où :

      • OPDK_VERSION correspond à la version d'Apigee Edge pour Private Cloud que vous souhaitez installer.
      • APIGEE_REPO_URL est l'URL du dépôt Apigee.

    12. Exportez le fichier de configuration en tant que variable d'environnement : 
      export ANSIBLE_CONFIG=~/.ansible/multi-planet-configurations/prod.cfg

    Installer les composants Apigee

    Au cours de cette étape, l'opérateur GDC installe les composants Apigee à l'aide d'Ansible.

    Pour installer les composants Apigee :

    1. Remplacez les dépôts Git distants par des fichiers locaux : 
      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. Installez les exigences Ansible : 
      ansible-galaxy install -r requirements.yml -f
    3. Corrigez les rôles 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. Remplacez le contenu du fichier install.yml par celui de apigee/scripts/ansible/install.yml.
    5. Exécutez le playbook pour installer les composants Apigee : 
      ansible-playbook install.yml
    6. Désactivez le lien de réinitialisation du mot de passe de l'utilisateur dans l'interface utilisateur Edge. Apigee sur GDC air-gapped n'inclut pas de serveur SMTP. Suivez la procédure décrite dans Désactiver le lien de réinitialisation du mot de passe dans l' UI Edge.

    Déployer des pods et des services

    À cette étape, vous allez déployer les pods et services d'importateur, de proxy inverse, d'équilibreur de charge et de journalisation.

    Pour déployer les pods et les services :

    1. Suivez les instructions de la section Créer des instances de registre Harbor pour créer une instance Harbor dans le projet GDC dev-apigee.
    2. Suivez les instructions de Créer des projets Harbor pour créer un projet Harbor nommé apigee.
    3. Suivez les instructions de la section Configurer le contrôle des accès pour configurer le contrôle des accès pour le projet Harbor.
    4. Suivez les instructions de la section Se connecter à Docker et Helm pour configurer l'authentification Docker.
    5. Mettez à jour les adresses IP dans le fichier apigee/apigee_user_cluster.toml comme indiqué : 
      mgmt-server-proxy = "APIGEE_NODE1_EXTERNAL_IP"
router-proxy1 = "APIGEE_NODE2_EXTERNAL_IP"
router-proxy2 = "APIGEE_NODE3_EXTERNAL_IP"

      Où :

      • APIGEE_NODE1_EXTERNAL_IP correspond à l'adresse IP externe du nœud Apigee 1 obtenue lors d'une étape précédente.
      • APIGEE_NODE2_EXTERNAL_IP correspond à l'adresse IP externe du nœud Apigee 2 obtenue lors d'une étape précédente.
      • APIGEE_NODE3_EXTERNAL_IP correspond à l'adresse IP externe du nœud Apigee3 obtenue lors d'une étape précédente.

    6. Placez le fichier de certificat SSL (server.crt) et le fichier de clé (server.key) pour configurer HTTPS dans les dossiers apigee/mgmt-server-proxy et apigee/router-proxy.

      Pour générer des certificats autosignés, utilisez la commande suivante : 

      openssl req -newkey rsa:4096 -x509 -nodes -keyout server.key -new -out server.crt -subj "/CN=*.apigeetest.com" -sha256 -days 365
    7. Mettez à jour la valeur de SSH-PASSWORD pour l'utilisateur racine dans le conteneur d'importation du fichier apigee/uploader/Dockerfile : 
      RUN echo 'root:SSH_PASSWORD' | chpasswd
    8. Obtenez les identifiants du cluster d'utilisateur : 
      gdcloud clusters get-credentials USER_CLUSTER

      où USER_CLUSTER est le nom du cluster GKE utilisateur.

    9. Exécutez le script de déploiement pour déployer les pods et les services : 
      source venv/bin/activate
python apigee/solution_deploy_user_cluster.py gdc-air-gapped
    10. Récupérez les adresses IP externes des services : 
      kubectl get svc -n $PROJECT_ID

    Mettre à jour les adresses IP de l'outil d'importation et du transmetteur Fluent Bit

    Dans cette étape, vous allez mettre à jour les adresses IP de l'outil d'importation et du transmetteur Fluent Bit dans les scripts de sauvegarde et de configuration d'Apigee.

    1. Mettre à jour SSH_PASSWORD, root et UPLOADER_EXTERNAL_IP dans 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/

      Où :

      • SSH_PASSWORD est le mot de passe de l'utilisateur racine.
      • UPLOADER_EXTERNAL_IP correspond à l'adresse IP externe du service d'importation obtenue lors d'une étape précédente.

    2. Mettre à jour FLUENTBIT_EXTERNAL_IP dans apigee/helm/scripts/apigee_setup.sh : 
      export FLUENTBIT_EXTERNAL_IP=FLUENTBIT_EXTERNAL_IP

    La mise à jour du script de démarrage nécessite le redémarrage des nœuds Apigee. Pour redémarrer les nœuds :

    1. Arrêtez les 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. Redéployez le chart Helm : 
      python apigee/solution_deploy.py gdc-air-gapped
    3. Démarrez les VM : 
      for i in 1 2 3 4 5; do
  GDCloud compute instances start node$i --project $PROJECT
  done

    Intégrer l'organisation Apigee

    Au cours de cette étape, l'opérateur GDC intègre l'organisation Apigee en exécutant un script de configuration sur node1.

    Pour intégrer l'organisation Apigee :

    1. Mettez à jour les valeurs suivantes dans apigee/scripts/apigee_org_setup.sh comme indiqué. Mettez à jour les autres paramètres si nécessaire. 
      IP1=APIGEE_NODE1_INTERNAL_IP

VHOST_ALIAS="APIGEE_NODE2_EXTERNAL_IP:9001 APIGEE_NODE3_EXTERNAL_IP:9001"

      Où :

      • APIGEE_NODE1_INTERNAL_IP correspond à l'adresse IP interne du nœud 1 Apigee obtenue lors d'une étape précédente.
      • APIGEE_NODE2_EXTERNAL_IP correspond à l'adresse IP externe du nœud Apigee 2 obtenue lors d'une étape précédente.
      • APIGEE_NODE3_EXTERNAL_IP correspond à l'adresse IP externe du nœud Apigee3 obtenue lors d'une étape précédente.

    2. Exécutez le script sur node1 pour intégrer l'organisation : 
      chmod a+x apigee_org_setup.sh
./apigee_org_setup.sh

    Tester la connectivité HTTP

    Dans cette étape, vous allez tester la connectivité HTTP pour l'API Management et le proxy d'API.

    Pour tester la connectivité HTTP :

    1. Recherchez l'adresse IP externe du service apigee-elb : 
      gdcloud clusters get-credentials USER_CLUSTER
export PROJECT=dev-apigee
kubectl get svc apigee-elb -n $PROJECT

      où USER_CLUSTER est le nom du cluster GKE utilisateur.

      Ce service sert de point de terminaison pour l'UI Edge, l'API Management et le proxy d'API.

    Tester l'API Management

    Pour tester l'API Management, envoyez une requête HTTP au point de terminaison : 

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

    Où :

    • APIGEE_ELB_EXTERNAL_IP correspond à l'adresse IP externe du service apigee-elb obtenue lors d'une étape précédente.
    • ORG_NAME est le nom de l'organisation Apigee.
    • ENV_NAME est le nom de l'environnement Apigee.

    Tester le proxy d'API

    Pour tester le proxy d'API :

    1. Connectez-vous à l'interface utilisateur Edge.
    2. Sur la page Proxys d'API, cliquez sur Créer pour créer un proxy d'API.
    3. Sur la page Détails du proxy, saisissez les valeurs suivantes :
      • Type de proxy : sélectionnez Aucune cible.
      • Nom du proxy : ok
      • Base Path /ok
      • Cible : http://APIGEE_ELB_EXTERNAL_IP:9001
    4. Cliquez sur Créer pour créer le proxy d'API.
    5. Envoyez une requête HTTP à /ok : 
      curl -i http://APIGEE_ELB_EXTERNAL_IP:9001/ok
    6. Vérifiez que la réponse est 200 OK.

    Configurer TLS et tester HTTPS

    Lors de cette étape, l'opérateur GDC configure Transport Layer Security (TLS) pour le proxy d'API, l'UI Edge et l'API Management.

    Configurer TLS pour le proxy d'API

    1. Suivez les étapes de la section Créer un keystore/truststore et un alias pour créer un certificat autosigné avec les valeurs suivantes :
      • KeyStore : myTestKeystore
      • KeyAlias : myKeyAlias
      • Nom commun : apigeetest.com
    2. Effectuez un appel d'API pour créer l'hôte virtuel nommé 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>'

      Où :

      • APIGEE_ELB_EXTERNAL_IP correspond à l'adresse IP externe du service apigee-elb obtenue lors d'une étape précédente.
      • ORG_NAME est le nom de l'organisation Apigee.
      • ENV_NAME est le nom de l'environnement Apigee dans lequel l'hôte virtuel doit être créé.
    3. Créez un proxy d'API à l'aide de l'hôte virtuel sécurisé.
    4. Sur les routeurs, configurez la résolution DNS pour les hôtes virtuels : 
      echo '127.0.0.1 api.apigeetest.com' | sudo tee -a /etc/hosts
    5. Vérifiez que les hôtes virtuels fonctionnent localement en envoyant une requête HTTPS au point de terminaison : 
      curl https://api.apigeetest.com:9005/ok -v -k
    6. Configurez la résolution DNS pour le point de terminaison : 
      echo 'APIGEE_ELB_EXTERNAL_IP apigeetest.com' | sudo tee -a /etc/hosts

      Où APIGEE_ELB_EXTERNAL_IP est l'adresse IP externe du service apigee-elb obtenue lors d'une étape précédente.

    7. Accédez à https://apigeetest.com/ok dans un navigateur Web et vérifiez que cela fonctionne.

    Configurer TLS pour l'interface utilisateur Edge

    Pour configurer TLS pour l'interface utilisateur Edge :

    1. Générez un fichier keystore à partir du fichier de certificat SSL et du fichier de clé : 
      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. Placez le fichier keystore dans le dossier Apigee sur node1 : 
      scp -i SSH_PRIVATE_KEY_FILE keystore.jks admin@APIGEE_NODE1_EXTERNAL_IP:/home/admin/

      Où :

      • SSH_PRIVATE_KEY_FILE est le nom du fichier contenant la clé privée SSH de votre nœud Apigee.
      • APIGEE_NODE1_EXTERNAL_IP correspond à l'adresse IP externe du nœud Apigee 1 obtenue lors d'une étape précédente.

    3. Connectez-vous en SSH à node1 et déplacez le fichier keystore dans le dossier Apigee : 
      sudo mv keystore.jks /opt/apigee/customer/application/
    4. Créez le fichier de configuration SSL : 
      sudo vi /tmp/sslConfigFile
    5. Mettez à jour la valeur de KEY-PASS-PHRASE comme indiqué : 
      HTTPSPORT=9443
DISABLE_HTTP=n
KEY_ALGO=JKS
KEY_FILE_PATH=/opt/apigee/customer/application/keystore.jks
KEY_PASS=KEY_PASS_PHRASE
    6. Configurez SSL à l'aide du fichier de configuration : 
      sudo chown apigee:apigee /tmp/sslConfigFile
/opt/apigee/apigee-service/bin/apigee-service edge-ui configure-ssl -f /tmp/sslConfigFile
    7. Configurez la résolution DNS pour l'interface utilisateur Edge : 
      echo 'APIGEE_ELB_EXTERNAL_IP ui.apigeetest.com' | sudo tee -a /etc/hosts

      Où APIGEE_ELB_EXTERNAL_IP est l'adresse IP externe du service apigee-elb obtenue lors d'une étape précédente.

    8. Accédez à https://ui.apigeetest.com:9443 dans un navigateur Web et vérifiez que cela fonctionne. Pour en savoir plus, consultez le guide.

    Configurer TLS pour l'API Management

    Pour configurer TLS pour l'API Management :

    1. Configurez le propriétaire du fichier keystore (utilisez le même que pour l'interface utilisateur Edge) : 
      sudo chown apigee:apigee /opt/apigee/customer/application/keystore.jks
    2. Créez le fichier de propriétés : 
      sudo vi /opt/apigee/customer/application/management-server.properties

      3. Remplacez la valeur de KEY_PASS_PHRASE par le mot de passe du keystore, comme indiqué : 

      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. Redémarrez le serveur de gestion pour que les modifications prennent effet : 
      /opt/apigee/apigee-service/bin/apigee-service edge-management-server restart
    4. Vérifiez que le protocole HTTPS fonctionne localement : 
      curl -u "opdk@apigee.com:Apigee123!" "https://localhost:8443/v1/users" -k
    5. Depuis le client, accédez à https://apigeetest.com:8443/v1/users dans le navigateur. Saisissez le nom d'utilisateur et le mot de passe de l'administrateur pour confirmer que les identifiants sont correctement configurés.

    Étape suivante