Instalowanie Apigee w Google Distributed Cloud z odcięciem od sieci zewnętrznych

Ten przewodnik opisuje, jak zainstalować i wdrożyć Apigee Edge for Private Cloud oraz serwery proxy interfejsu API w środowisku Google Distributed Cloud (GDC) bez dostępu do internetu. Oferty GDC air-gapped, w tym Apigee Edge for Private Cloud, nie wymagają połączenia z Google Cloud do zarządzania infrastrukturą i usługami. W przypadku wszystkich operacji możesz używać lokalnej płaszczyzny sterowania hostowanej w Twojej infrastrukturze. Omówienie GDC w sieci odseparowanej znajdziesz w tym artykule.

Ten przewodnik jest przeznaczony dla operatorów Apigee, którzy znają Apigee Edge Private Cloud i mają podstawową wiedzę o Kubernetes.

Omówienie wymaganych czynności

Aby zainstalować i wdrożyć Apigee Edge for Private Cloud w środowisku GDC bez dostępu do internetu, operator musi wykonać te czynności:

Zanim zaczniesz

Zanim rozpoczniesz proces instalacji, wykonaj te czynności:

  1. Jeśli nie masz jeszcze projektu GDC, utwórz go na potrzeby instalacji. Więcej informacji znajdziesz w artykule Tworzenie projektu.
  2. Pobierz, zainstaluj i skonfiguruj interfejs gdcloud CLI na stacji roboczej połączonej z GDC lub w środowisku ciągłego wdrażania organizacji.
  3. Uzyskaj dane logowania wymagane do korzystania z interfejsu wiersza poleceń gdcloud i interfejsu API kubectl. Wymagane czynności znajdziesz w artykule Uwierzytelnianie konta w celu uzyskania dostępu.
  4. Potwierdź nazwę użytkownika i hasło do Apigee otrzymane od menedżera konta Apigee.
  5. Sprawdź nazwę klastra administracyjnego GKE i nazwę klastra użytkownika GKE.

Wymagania dotyczące pojemności

Instalacja Apigee Edge w chmurze prywatnej w GDC wymaga kilku maszyn wirtualnych z określonymi przydziałami zasobów. Za te maszyny wirtualne naliczane są opłaty na podstawie ich zasobów obliczeniowych (pamięci RAM, rdzeni procesora wirtualnego) i miejsca na dysku lokalnym. Więcej informacji znajdziesz w sekcji Ceny.

W tabeli poniżej znajdziesz wymagania dotyczące zasobów dla poszczególnych maszyn wirtualnych:

Typ maszyny wirtualnej Pamięć RAM Rdzenie procesorów wirtualnych Miejsce na dysku
Węzeł repozytorium 8 GB 2 rdzenie vCPU 64 GB
Węzeł sterujący 8 GB 2 rdzenie vCPU 64 GB
Węzły 1, 2 i 3 usługi Apigee do zarządzania interfejsami API 16 GB RAM 8 rdzeni vCPU 670 GB
Węzły zarządzania interfejsami API Apigee 4 i 5 16 GB RAM 8 rdzeni vCPU 500 GB–1 TB

Role i uprawnienia

Aby wdrożyć Apigee Edge for Private Cloud w odizolowanym środowisku GDC, musisz mieć te role i uprawnienia:

  • Administrator platformy: przypisz rolę IAM Admin.
  • Operator aplikacji (AO): przypisz te role:
    • Harbor Instance Admin: ma pełny dostęp do zarządzania instancjami Harbor w projekcie.
    • LoggingTarget Creator: tworzy LoggingTarget niestandardowe zasoby w przestrzeni nazw projektu.
    • LoggingTarget Editor: edytuje LoggingTarget niestandardowe zasoby w przestrzeni nazw projektu.
    • Project Bucket Admin: zarządza zasobnikami pamięci i obiektami w zasobnikach.
    • Project Grafana Viewer: uzyskuje dostęp do instancji monitorowania w przestrzeni nazw projektu.
    • Project NetworkPolicy Admin: zarządza zasadami sieciowymi projektu w przestrzeni nazw projektu.
    • Project VirtualMachine Admin: zarządza maszynami wirtualnymi w przestrzeni nazw projektu.
    • Secret Admin: zarządza obiektami tajnymi Kubernetes w projektach.
    • Service Configuration Admin: ma uprawnienia do odczytu i zapisu konfiguracji usług w przestrzeni nazw projektu.
    • Namespace Admin: zarządza wszystkimi zasobami w przestrzeniach nazw projektu.

    • Więcej informacji o przyznawaniu ról i uprawnień w przypadku odciętej od internetu wersji GDC znajdziesz w artykule Przyznawanie i odbieranie dostępu.

    Ograniczenia

    W przypadku Apigee na odseparowanej sieci GDC obowiązują te ograniczenia:

    • Apigee w izolowanym środowisku GDC nie ma serwerów DNS i jako obejście używa lokalnego rozpoznawania DNS. Jeśli Apigee na GDC w trybie air-gapped jest wdrażane w środowisku z zewnętrznymi serwerami DNS, zastąp kroki, które konfigurują lokalny DNS, konfiguracją wpisów DNS na serwerach DNS.
    • Apigee w przypadku odseparowanego środowiska GDC nie zawiera samodzielnego serwera SMTP. Serwer SMTP możesz skonfigurować w dowolnym momencie, aby włączyć powiadomienia e-mail o tworzeniu kont i resetowaniu haseł z serwera zarządzania i interfejsu zarządzania. Interfejsy API do zarządzania pozostają dostępne na potrzeby zarządzania kontami użytkowników Apigee. Więcej informacji znajdziesz w artykule Konfigurowanie serwera SMTP Edge.
    • Apigee w izolowanej sieci GDC nie implementuje wykrywania i zapobiegania włamaniom. Zainstaluj i skonfiguruj system zapobiegania włamaniom, np. Snort, aby wykrywać złośliwe działania i im zapobiegać.

    Pobierz wymagane pliki

    Aby uzyskać pliki instalacyjne, musisz najpierw skonfigurować połączony węzeł, a potem pobrać pliki.

    Konfigurowanie połączonego węzła

    Połączony węzeł to pojedyncza maszyna wirtualna poza GDC, której używasz do pobierania plików instalacyjnych. Ta maszyna wirtualna wymaga dostępu do internetu i jest używana tylko w procesie instalacji.

    Połączony węzeł wymaga następującej pojemności i konfiguracji:

    • System operacyjny: Rocky Linux 8
    • Rozmiar maszyny: 8 GB pamięci RAM, 2 rdzenie vCPU, 64 GB lokalnej pamięci dyskowej
    • Połączenia:
      • Ruch przychodzący: TCP 22 (SSH)
      • Ruch wychodzący: internet

    Aby utworzyć połączony węzeł, postępuj zgodnie z instrukcjami w artykule Tworzenie i uruchamianie instancji maszyny wirtualnej. Po utworzeniu maszyny wirtualnej postępuj zgodnie z instrukcjami w artykule Łączenie się z maszynami wirtualnymi z systemem Linux. aby połączyć się z maszyną wirtualną. Listę obsługiwanych systemów operacyjnych znajdziesz w artykule Obsługiwane systemy operacyjne GDC.

    Pobieranie plików instalacyjnych

    Aby pobrać pliki instalacyjne:

    1. Najnowszą oficjalną wersję obsługiwaną w GDC znajdziesz w informacjach o wersji Apigee Edge for Private Cloud w kolumnie Edge for Private Cloud.
    2. Pobierz plik instalacyjny Edge: 
      curl https://software.apigee.com/apigee/tarball/VERSION/rocky8/archive.tar -o /tmp/archive.tar -u 'APIGEE_USER:APIGEE_PASSWORD'

      Gdzie:

      • APIGEE_USER to nazwa użytkownika otrzymana dla organizacji Apigee.
      • APIGEE_PASSWORD to hasło otrzymane dla organizacji Apigee.
      • VERSION to wersja Apigee Edge for Private Cloud do użycia w GDC, którą chcesz zainstalować, np. 4.53.01.
    3. Pobierz najnowszy plik Apigee Edge Private Cloud bootstrap_VERSION.sh do /tmp/bootstrap_VERSION.sh: 
      curl https://software.apigee.com/bootstrap_VERSION.sh -o /tmp/bootstrap_VERSION.sh

      gdzie VERSION to najnowsza wersja Apigee Edge for Private Cloud do zainstalowania w GDC, np. 4.53.01.

    4. Zainstaluj narzędzie Edge apigee-service i zależności: 
      sudo bash /tmp/bootstrap_VERSION.sh apigeeuser=APIGEE_USER apigeepassword=APIGEE_PASSWORD

      Gdzie:

      • APIGEE_USER to nazwa użytkownika otrzymana dla organizacji Apigee.
      • APIGEE_PASSWORD to hasło otrzymane dla organizacji Apigee.
      • VERSION to wersja Apigee Edge for Private Cloud do użycia w GDC, którą chcesz zainstalować.

    5. Uruchom skrypt konfiguracji w połączonym węźle: 
      chmod a+x connected-node_setup.sh \
  ./connected-node_setup.sh

      W tym kroku skrypt generuje wymagane pliki w tych lokalizacjach (na przykład w przypadku wersji 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. Przenieś wymagane pliki z połączonego węzła na komputer lokalny za pomocą 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

      Gdzie:

      • SSH_PRIVATE_KEY_FILE to ścieżka do pliku klucza prywatnego SSH.
      • USER to nazwa użytkownika połączonego węzła.
      • CONNECTED_NODE_IP to adres IP połączonego węzła.

    Konfigurowanie zasobnika na dane

    W tym kroku operator GDC konfiguruje w projekcie GDC zasobnik pamięci do przechowywania plików kopii zapasowych Apigee Edge dla chmury prywatnej.

    Utwórz zasobnik na dane

    Aby utworzyć zasobnik pamięci w projekcie GDC:

    1. Uwierzytelnij się w klastrze administratora organizacji: 
      gdcloud auth login --login-config-cert WEB_TLS_CERT
gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      Gdzie:

      • WEB_TLS_CERT to ścieżka do certyfikatu TLS sieci.
      • ORG_ADMIN_CLUSTER to nazwa klastra GKE administratora organizacji.

    2. Ustaw zmienne środowiskowe projektu i zasobnika: 
      export PROJECT=PROJECT
export BUCKET=BUCKET_NAME

      Gdzie:

      • PROJECT to nazwa Twojego projektu GDC.
      • BUCKET_NAME to nazwa zasobnika, który chcesz utworzyć do przechowywania plików kopii zapasowej Apigee Edge Private Cloud.
    3. Zastosuj konfigurację zasobnika: 
      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

      Ta konfiguracja tworzy zasobnik z okresem przechowywania wynoszącym 30 dni.

    Konfigurowanie dostępu do zasobnika

    Aby skonfigurować dostęp do zasobnika pamięci:

    1. Utwórz konto usługi w projekcie: 
      gdcloud iam service-accounts create $BUCKET-sa \
    --project=$PROJECT
    2. Utwórz rolę i powiązanie roli, aby wygenerować klucz tajny umożliwiający dostęp do zasobnika: 
      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. Pobierz identyfikator klucza dostępu i klucz z obiektu tajnego: 
      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']}")"

      Dane wyjściowe powinny wyglądać podobnie do tych: 

      access-key-id=RFdJMzRROVdWWjFYNTJFTzJaTk0=
access-key=U3dSdm5FRU5WdDhMckRMRW1QRGV0bE9MRHpCZ0Ntc0cxVFJQdktqdg==
    4. Utwórz klucz tajny, który będzie używany przez program przesyłający w klastrze GKE użytkownika:
      1. Uwierzytelnij się w klastrze użytkownika GKE: 
        gdcloud clusters get-credentials USER_CLUSTER

        gdzie USER_CLUSTER to nazwa klastra GKE użytkownika.

      2. Zastosuj konfigurację tajnego klucza: 
        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

        Gdzie:

        • ACCESS_KEY_ID to identyfikator klucza dostępu uzyskany w poprzednim kroku.
        • ACCESS_KEY to klucz dostępu uzyskany w poprzednim kroku.
    5. Pobierz punkt końcowy pamięci, pełną i jednoznaczną nazwę domeny (FQDN) oraz region zasobnika:
      1. Uwierzytelnij się w klastrze administratora organizacji: 
        gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

        gdzie ORG_ADMIN_CLUSTER to nazwa klastra GKE administratora organizacji.

      2. Pobierz punkt końcowy pamięci, pełną i jednoznaczną nazwę domeny (FQDN) oraz region zasobnika: 
        kubectl get buckets ${BUCKET} -n $PROJECT -o jsonpath="{'endpoint: '}{.status.endpoint}{'\n'}{'bucket: '}{.status.fullyQualifiedName}{'\n'}{'region: '}{.status.region}{'\n'}"

        Dane wyjściowe powinny wyglądać podobnie do tych:

        endpoint: https://objectstorage.gpu-org.cookie.sesame.street
bucket: ez9wo-apigee-backup-bucket
region: cookie
    6. Zmień te wartości w pliku apigee/helm_user_cluster/values-cookie-air-gapped.yaml: 
      objectstorekeyname: "apigee-backup-bucket-secret"
objectstoreurl: "BUCKET_ENDPOINT"
objectstorebucket: "BUCKET_FQDN"

      Gdzie:

      • BUCKET_ENDPOINT to punkt końcowy zasobnika uzyskany w poprzednim kroku.
      • BUCKET_FQDN to pełna i jednoznaczna nazwa domeny zasobnika uzyskana w poprzednim kroku.

    Konfigurowanie węzła repozytorium

    W tym kroku operator GDC konfiguruje węzeł repozytorium, w którym będzie hostowane repozytorium kopii Apigee Edge dla Private Cloud.

    Tworzenie węzła repozytorium

    Aby utworzyć węzeł repozytorium:

    1. Zaktualizuj apigee/helm_user_cluster/values-cookie-air-gapped.yaml w ten sposób: 
      repo_node:
  enabled: true

apigee_node:
  enabled: false

control_node:
  enabled: false

      Sprawdź, czy repo_node jest włączony, a apigee_node i control_node są wyłączone. Te węzły zostaną wdrożone w późniejszym kroku.

    2. Pobierz dane logowania do klastra administratora organizacji: 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      gdzie ORG_ADMIN_CLUSTER to nazwa klastra GKE administratora organizacji.

    3. Utwórz środowisko wirtualne Pythona: 
      python3 -m venv venv /
source venv/bin/activate
    4. Uruchom skrypt wdrażania, aby utworzyć węzeł repozytorium: 
      python apigee/solution_deploy.py gdc-air-gapped

    Konfigurowanie dostępu do węzła repozytorium

    Aby skonfigurować dostęp do węzła repozytorium:

    1. Skonfiguruj SSH dla węzła repozytorium: 
      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

      gdzie SSH_PUBLIC_KEY_FILE to nazwa pliku zawierającego Twój publiczny klucz SSH.

    2. Uzyskaj zewnętrzny adres IP węzła repozytorium: 
      kubectl get virtualmachineexternalaccess -n $PROJECT $NODE -ojsonpath='{.status.ingressIP}'
    3. Uzyskaj wewnętrzny adres IP węzła repozytorium: 
      kubectl get virtualmachines.virtualmachine.gdc.goog -n $PROJECT $NODE -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

    Przesyłanie plików instalacyjnych

    W tym kroku operator GDC przesyła do węzła repozytorium najnowszą wersję tych plików:

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

    Aby przesłać pliki instalacyjne:

    1. Skopiuj plik klucza prywatnego SSH do węzła repozytorium: 
      scp -i SSH_PRIVATE_KEY_FILE ~/apigee-files/* admin@REPO_EXTERNAL_IP:/tmp

      Gdzie:

      • SSH_PRIVATE_KEY_FILE to nazwa pliku zawierającego prywatny klucz SSH.
      • REPO_EXTERNAL_IP to zewnętrzny adres IP węzła repozytorium uzyskany w poprzednim kroku.
    2. Prześlij folder zawierający konfiguracje Fluent Bit do węzła repozytorium: 
      scp -i SSH-PRIVATE-KEY-FILE -r apigee/scripts/fluent-bit admin@REPO_EXTERNAL_IP:/tmp/fluent-bit

      Gdzie:

      • SSH_PRIVATE_KEY_FILE to nazwa pliku zawierającego prywatny klucz SSH.
      • REPO_EXTERNAL_IP to zewnętrzny adres IP węzła repozytorium.

    Konfigurowanie repozytorium kopii

    Aby skonfigurować repozytorium kopii:

    1. Skopiuj identyfikator apigee/scripts/repo_setup.sh do węzła repozytorium.
    2. W skrypcie zastąp REPO_USER i REPO_PASSWORD odpowiednią nazwą użytkownika i hasłem do repozytorium kopii.
    3. Uruchom skrypt: 
      chmod a+x repo_setup.sh
./repo_setup.sh

      Jeśli pojawi się błąd No such file or directory, uruchom skrypt ponownie.

    4. Przetestuj połączenie z repozytorium kopii lokalnie z węzła repozytorium. 
      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

      Zastąp VERSION wersją Apigee Edge for Private Cloud, którą chcesz zainstalować.

    Wdrażanie węzłów Apigee

    W tym kroku operator GDC wdraża węzły zarządzania interfejsem API Apigee.

    Tworzenie węzłów Apigee

    Aby utworzyć węzły zarządzania interfejsem API Apigee:

    1. Zastąp parametry REPO_INTERNAL_IP, REPO_USER_NAME i REPO_PASSWORD w apigee/helm/scripts/apigee_setup.sh odpowiednimi wartościami.
    2. Wyeksportuj wartości jako zmienne środowiskowe: 
      export REPO_IP=REPO_INTERNAL_IP
export REPO_USER=REPO_USER_NAME
export REPO_PASSWORD=REPO_PASSWORD
    3. Włącz apigee_node w apigee/helm/values-cookie-air-gapped.yaml, jak pokazano poniżej: 
      apigee_node:
  enabled: true
    4. Uruchom skrypt wdrażania, aby utworzyć węzły Apigee: 
        source venv/bin/activate
  python apigee/solution_deploy.py gdc-air-gapped

    Konfigurowanie dostępu do węzła Apigee

    Skonfiguruj dostęp do węzłów zarządzania interfejsami API Apigee:

    1. Uwierzytelnij się w klastrze administratora organizacji: 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      gdzie ORG_ADMIN_CLUSTER to nazwa klastra GKE administratora organizacji.

    2. Utwórz klucz SSH dla każdego węzła: 
      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

      gdzie SSH_PUBLIC_KEY_FILE to nazwa pliku zawierającego Twój publiczny klucz SSH.

    3. Pobierz zewnętrzne adresy IP węzłów Apigee: 
      for i in 1 2 3 4 5; do
  kubectl get virtualmachineexternalaccess -n $PROJECT node$i -ojsonpath='{.status.ingressIP}'
  echo
  done
    4. Uzyskaj wewnętrzne adresy IP węzłów 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. (Opcjonalnie) Sprawdź, czy skrypty uruchamiania działają prawidłowo na węzłach Apigee:
      1. Nawiąż połączenie SSH z węzłem i uruchom to polecenie: 
        sudo journalctl -u cloud-final -f
      2. Poszukaj logów podobnych do tych: 
        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

    Konfigurowanie węzła sterującego

    W tym kroku operator GDC konfiguruje węzeł sterujący do zarządzania instalacjami Apigee.

    Tworzenie węzła sterującego

    Aby utworzyć węzeł sterujący:

    1. Zastąp parametry REPO_INTERNAL_IP, REPO_USER_NAME i REPO_PASSWORD w apigee/helm/scripts/control_setup.sh wybranymi wartościami.
    2. Włącz funkcję control_node w apigee/helm/values-cookie-air-gapped.yaml, jak pokazano poniżej: 
      control_node:
  enabled: true
    3. Uruchom skrypt wdrażania, aby utworzyć węzeł sterujący: 
      source venv/bin/activate
python apigee/solution_deploy.py gdc-air-gapped

    Konfigurowanie dostępu do węzła sterującego

    Aby skonfigurować dostęp do węzła sterującego:

    1. Skonfiguruj dostęp SSH do węzła sterującego: 
      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. Uzyskaj zewnętrzny adres IP węzła sterującego: 
      kubectl get virtualmachineexternalaccess -n $PROJECT control -ojsonpath='{.status.ingressIP}'
    3. Uzyskaj wewnętrzny adres IP węzła sterującego: 
      kubectl get virtualmachines.virtualmachine.GDC.goog -n $PROJECT control -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

    Konfigurowanie Ansible

    W tym kroku operator GDC konfiguruje środowisko na węźle sterującym.

    Aby skonfigurować środowisko Ansible:

    1. Połącz się z węzłem sterującym przez SSH i skonfiguruj środowisko Ansible: 
      cd /home/admin
cp -r /tmp/apigee-repos .
cd apigee-repos/ansible-opdk-accelerator/setup
    2. Zastąp zdalne repozytoria Git plikiem lokalnym: 
      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. Zaktualizuj konfigurację:
      1. Edytuj plik main.yml: 
        vi ~/apigee-repos/ansible-opdk-accelerator/setup/roles/apigee-opdk-setup-ansible-controller/tasks/main.yml
      2. Usuń zadania, które wymagają dostępu do GitHub:
        • Wyewidencjonowywanie repozytoriów konfiguracji za pomocą SSH w Git
        • Wyewidencjonowywanie repozytoriów konfiguracji z Git przez HTTPS
      3. Uruchom scenariusz konfiguracji: 
        cd ~/apigee-repos/ansible-opdk-accelerator/setup
ansible-playbook setup.yml
    5. Prześlij klucz SSH dla węzłów Apigee do węzła sterującego: 
      scp -i CONTROL_SSH_PRIVATE_KEY_FILE APIGEE_NODE_SSH_PRIVATE_KEY_FILE admin@CONTROL_EXTERNAL_IP:/home/admin/.ssh/id_rsa

      Gdzie:

      • CONTROL_SSH_PRIVATE_KEY_FILE to nazwa pliku zawierającego klucz prywatny SSH węzła sterującego.
      • APIGEE_NODE_SSH_PRIVATE_KEY_FILE to nazwa pliku zawierającego klucz prywatny SSH węzła Apigee.
      • CONTROL_EXTERNAL_IP to zewnętrzny adres IP węzła sterującego.
    6. Utwórz plik konfiguracji zasobów Ansible:
      1. Skopiuj zawartość pliku apigee/scripts/ansible/prod.cfg do pliku prod.cfg: 
        vi ~/.ansible/multi-planet-configurations/prod.cfg
      2. Utwórz folder edge-dc1 i skopiuj do niego zawartość pliku apigee/scripts/ansible/edge-dc1:edge-dc1 
        mkdir ~/.ansible/inventory/prod
vi ~/.ansible/inventory/prod/edge-dc1
    7. Zaktualizuj wewnętrzne adresy IP węzłów Apigee w 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

      Wartości APIGEE_NODE*_INTERNAL_IP to wewnętrzne adresy IP węzłów Apigee uzyskane w poprzednim kroku.

    8. Skonfiguruj plik ~/.apigee-secure/credentials.yml, używając tych wartości:
      • 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'

      Gdzie:

      • APIGEE_REPO_USER to nazwa użytkownika repozytorium Apigee.
      • APIGEE_REPO_PASSWORD to hasło do repozytorium Apigee.
      • OPDK_QPID_MGMT_USERNAME to nazwa użytkownika serwera zarządzania Apigee QPID.
      • OPDK_QPID_MGMT_PASSWORD to hasło serwera zarządzania Apigee QPID.

    9. Dodaj plik licencji z prawidłowym plikiem licencji Apigee Edge for Private Cloud. Nazwa pliku musi mieć postać license.txt.
    10. Skopiuj zawartość pliku ~/.apigee-secure/license.txt do utworzonego przed chwilą pliku license.txt.
    11. Skonfiguruj te wartości w pliku ~/.apigee/custom-properties.yml:
      • opdk_version: 'OPDK_VERSION'
      • apigee_repo_url: 'APIGEE_REPO_URL'

      Gdzie:

      • OPDK_VERSION to wersja Apigee Edge for Private Cloud, którą chcesz zainstalować.
      • APIGEE_REPO_URL to adres URL repozytorium Apigee.

    12. Wyeksportuj plik konfiguracji jako zmienną środowiskową: 
      export ANSIBLE_CONFIG=~/.ansible/multi-planet-configurations/prod.cfg

    Instalowanie komponentów Apigee

    W tym kroku operator GDC instaluje komponenty Apigee za pomocą Ansible.

    Aby zainstalować komponenty Apigee:

    1. Zastąp zdalne repozytoria Git plikami lokalnymi: 
      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. Zainstaluj wymagania Ansible: 
      ansible-galaxy install -r requirements.yml -f
    3. Zastosuj poprawki do ról 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. Zastąp zawartość pliku install.yml zawartością pliku apigee/scripts/ansible/install.yml.
    5. Uruchom scenariusz, aby zainstalować komponenty Apigee: 
      ansible-playbook install.yml
    6. Wyłącz link do resetowania hasła użytkownika w interfejsie Edge. Apigee w GDC w trybie air-gapped nie zawiera serwera SMTP. Wykonaj czynności opisane w artykule Wyłączanie linku do resetowania hasła w interfejsie Edge.

    Wdrażanie podów i usług

    W tym kroku wdrożysz pody i usługi przesyłania, serwera proxy, systemu równoważenia obciążenia i logowania.

    Aby wdrożyć pody i usługi:

    1. Aby utworzyć instancję Harbor w projekcie GDC dev-apigee, postępuj zgodnie z instrukcjami w artykule Tworzenie instancji rejestru Harbor.
    2. Postępuj zgodnie z instrukcjami w artykule Tworzenie projektów Harbor, aby utworzyć projekt Harbor o nazwie apigee.
    3. Aby skonfigurować kontrolę dostępu do projektu Harbor, postępuj zgodnie z instrukcjami w artykule Konfigurowanie kontroli dostępu.
    4. Aby skonfigurować uwierzytelnianie Dockera, postępuj zgodnie z instrukcjami w artykule Logowanie się w Dockerze i Helmie.
    5. Zaktualizuj adresy IP w pliku apigee/apigee_user_cluster.toml w ten sposób: 
      mgmt-server-proxy = "APIGEE_NODE1_EXTERNAL_IP"
router-proxy1 = "APIGEE_NODE2_EXTERNAL_IP"
router-proxy2 = "APIGEE_NODE3_EXTERNAL_IP"

      Gdzie:

      • APIGEE_NODE1_EXTERNAL_IP to zewnętrzny adres IP węzła Apigee node1 uzyskany w poprzednim kroku.
      • APIGEE_NODE2_EXTERNAL_IP to zewnętrzny adres IP węzła Apigee 2 uzyskany w poprzednim kroku.
      • APIGEE_NODE3_EXTERNAL_IP to zewnętrzny adres IP węzła Apigee3 uzyskany w poprzednim kroku.

    6. Umieść plik certyfikatu SSL (server.crt) i plik klucza (server.key) do skonfigurowania protokołu HTTPS w folderach apigee/mgmt-server-proxy i apigee/router-proxy.

      Aby wygenerować podpisane samodzielnie certyfikaty, użyj tego polecenia: 

      openssl req -newkey rsa:4096 -x509 -nodes -keyout server.key -new -out server.crt -subj "/CN=*.apigeetest.com" -sha256 -days 365
    7. Zaktualizuj wartość SSH-PASSWORD dla użytkownika root w kontenerze przesyłającym w pliku apigee/uploader/Dockerfile: 
      RUN echo 'root:SSH_PASSWORD' | chpasswd
    8. Pobierz dane logowania do klastra użytkownika: 
      gdcloud clusters get-credentials USER_CLUSTER

      gdzie USER_CLUSTER to nazwa klastra GKE użytkownika.

    9. Aby wdrożyć pody i usługi, uruchom skrypt wdrażania: 
      source venv/bin/activate
python apigee/solution_deploy_user_cluster.py gdc-air-gapped
    10. Sprawdź zewnętrzne adresy IP usług: 
      kubectl get svc -n $PROJECT_ID

    Aktualizowanie adresów IP przesyłającego i przekazującego Fluent Bit

    W tym kroku zaktualizujesz adresy IP narzędzia do przesyłania i przekazywania Fluent Bit w skryptach kopii zapasowej i konfiguracji Apigee.

    1. Zaktualizować: SSH_PASSWORD, root i UPLOADER_EXTERNAL_IP w: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/

      Gdzie:

      • SSH_PASSWORD to hasło roota.
      • UPLOADER_EXTERNAL_IP to zewnętrzny adres IP usługi przesyłania uzyskany w poprzednim kroku.

    2. Zaktualizować: FLUENTBIT_EXTERNAL_IP w: apigee/helm/scripts/apigee_setup.sh: 
      export FLUENTBIT_EXTERNAL_IP=FLUENTBIT_EXTERNAL_IP

    Aktualizacja skryptu uruchamiania wymaga ponownego uruchomienia węzłów Apigee. Aby ponownie uruchomić węzły:

    1. Zatrzymaj maszyny wirtualne: 
      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. Ponownie wdróż kartę Helm: 
      python apigee/solution_deploy.py gdc-air-gapped
    3. Uruchom maszyny wirtualne: 
      for i in 1 2 3 4 5; do
  GDCloud compute instances start node$i --project $PROJECT
  done

    Wprowadzanie organizacji Apigee

    W tym kroku operator GDC wdraża organizację Apigee, uruchamiając skrypt konfiguracji na node1.

    Aby wdrożyć organizację Apigee:

    1. Zaktualizuj te wartości w pliku apigee/scripts/apigee_org_setup.sh. W razie potrzeby zaktualizuj inne parametry. 
      IP1=APIGEE_NODE1_INTERNAL_IP

VHOST_ALIAS="APIGEE_NODE2_EXTERNAL_IP:9001 APIGEE_NODE3_EXTERNAL_IP:9001"

      Gdzie:

      • APIGEE_NODE1_INTERNAL_IP to wewnętrzny adres IP węzła Apigee node1 uzyskany w poprzednim kroku.
      • APIGEE_NODE2_EXTERNAL_IP to zewnętrzny adres IP węzła Apigee 2 uzyskany w poprzednim kroku.
      • APIGEE_NODE3_EXTERNAL_IP to zewnętrzny adres IP węzła Apigee3 uzyskany w poprzednim kroku.

    2. Uruchom skrypt na node1, aby wdrożyć organizację: 
      chmod a+x apigee_org_setup.sh
./apigee_org_setup.sh

    Testowanie połączeń HTTP

    W tym kroku przetestujesz połączenie HTTP z interfejsem Management API i serwerem proxy interfejsu API.

    Aby przetestować połączenie HTTP:

    1. Sprawdź zewnętrzny adres IP usługi apigee-elb: 
      gdcloud clusters get-credentials USER_CLUSTER
export PROJECT=dev-apigee
kubectl get svc apigee-elb -n $PROJECT

      gdzie USER_CLUSTER to nazwa klastra GKE użytkownika.

      Ta usługa działa jako punkt końcowy interfejsu Edge, interfejsu Management API i proxy interfejsu API.

    Testowanie interfejsu Management API

    Aby przetestować interfejs Management API, wyślij żądanie HTTP do punktu końcowego: 

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

    Gdzie:

    • APIGEE_ELB_EXTERNAL_IP to zewnętrzny adres IP usługi apigee-elb uzyskany w poprzednim kroku.
    • ORG_NAME to nazwa organizacji w Apigee.
    • ENV_NAME to nazwa środowiska Apigee.

    Testowanie proxy interfejsu API

    Aby przetestować proxy interfejsu API:

    1. Zaloguj się w interfejsie Edge.
    2. Na stronie API Proxies (Proxy interfejsu API) kliknij Create (Utwórz), aby utworzyć nowy proxy interfejsu API.
    3. Na stronie Szczegóły serwera proxy wpisz te wartości:
      • Typ serwera proxy: wybierz Brak celu.
      • Nazwa serwera proxy: ok
      • Ścieżka podstawowa: /ok
      • Cel: http://APIGEE_ELB_EXTERNAL_IP:9001
    4. Aby utworzyć serwer proxy interfejsu API, kliknij Utwórz.
    5. Wyślij żądanie HTTP do /ok: 
      curl -i http://APIGEE_ELB_EXTERNAL_IP:9001/ok
    6. Sprawdź, czy odpowiedź to 200 OK.

    Konfigurowanie protokołu TLS i testowanie protokołu HTTPS

    W tym kroku operator GDC konfiguruje protokół Transport Layer Security (TLS) dla serwera proxy interfejsu API, interfejsu Edge UI i interfejsu Management API.

    Konfigurowanie protokołu TLS dla serwera proxy interfejsu API

    1. Aby utworzyć certyfikat podpisany samodzielnie, wykonaj czynności opisane w artykule Tworzenie magazynu kluczy lub magazynu zaufanych certyfikatów i aliasu, używając tych wartości:
      • KeyStore: myTestKeystore
      • KeyAlias: myKeyAlias
      • Nazwa zwyczajowa: apigeetest.com
    2. Wywołaj interfejs API, aby utworzyć host wirtualny o nazwie 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>'

      Gdzie:

      • APIGEE_ELB_EXTERNAL_IP to zewnętrzny adres IP usługi apigee-elb uzyskany w poprzednim kroku.
      • ORG_NAME to nazwa organizacji w Apigee.
      • ENV_NAME to nazwa środowiska Apigee, w którym ma zostać utworzony host wirtualny.
    3. Utwórz serwer proxy interfejsu API za pomocą bezpiecznego hosta wirtualnego.
    4. Na routerach skonfiguruj rozpoznawanie nazw DNS dla hostów wirtualnych: 
      echo '127.0.0.1 api.apigeetest.com' | sudo tee -a /etc/hosts
    5. Sprawdź, czy wirtualni hostowie działają lokalnie, wysyłając żądanie HTTPS do punktu końcowego: 
      curl https://api.apigeetest.com:9005/ok -v -k
    6. Skonfiguruj rozpoznawanie nazw DNS dla punktu końcowego: 
      echo 'APIGEE_ELB_EXTERNAL_IP apigeetest.com' | sudo tee -a /etc/hosts

      gdzie APIGEE_ELB_EXTERNAL_IP to zewnętrzny adres IP usługi apigee-elb uzyskany w poprzednim kroku.

    7. Otwórz https://apigeetest.com/ok w przeglądarce i sprawdź, czy działa.

    Konfigurowanie protokołu TLS w interfejsie Edge

    Aby skonfigurować TLS w interfejsie Edge:

    1. Wygeneruj plik magazynu kluczy z pliku certyfikatu SSL i pliku klucza: 
      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. Umieść plik magazynu kluczy w folderze Apigee na serwerze node1: 
      scp -i SSH_PRIVATE_KEY_FILE keystore.jks admin@APIGEE_NODE1_EXTERNAL_IP:/home/admin/

      Gdzie:

      • SSH_PRIVATE_KEY_FILE to nazwa pliku zawierającego klucz prywatny SSH węzła Apigee.
      • APIGEE_NODE1_EXTERNAL_IP to zewnętrzny adres IP węzła Apigee node1 uzyskany w poprzednim kroku.

    3. Połącz się przez SSH z node1 i przenieś plik magazynu kluczy do folderu Apigee: 
      sudo mv keystore.jks /opt/apigee/customer/application/
    4. Utwórz plik konfiguracyjny SSL: 
      sudo vi /tmp/sslConfigFile
    5. Zmień wartość KEY-PASS-PHRASE w ten sposób: 
      HTTPSPORT=9443
DISABLE_HTTP=n
KEY_ALGO=JKS
KEY_FILE_PATH=/opt/apigee/customer/application/keystore.jks
KEY_PASS=KEY_PASS_PHRASE
    6. Skonfiguruj SSL za pomocą pliku konfiguracji: 
      sudo chown apigee:apigee /tmp/sslConfigFile
/opt/apigee/apigee-service/bin/apigee-service edge-ui configure-ssl -f /tmp/sslConfigFile
    7. Skonfiguruj rozpoznawanie nazw DNS dla interfejsu Edge: 
      echo 'APIGEE_ELB_EXTERNAL_IP ui.apigeetest.com' | sudo tee -a /etc/hosts

      gdzie APIGEE_ELB_EXTERNAL_IP to zewnętrzny adres IP usługi apigee-elb uzyskany w poprzednim kroku.

    8. Otwórz https://ui.apigeetest.com:9443 w przeglądarce i sprawdź, czy działa. Więcej informacji znajdziesz w przewodniku.

    Konfigurowanie protokołu TLS dla interfejsu Management API

    Aby skonfigurować TLS dla interfejsu Management API:

    1. Skonfiguruj właściciela pliku magazynu kluczy (użyj tego samego co w przypadku interfejsu Edge): 
      sudo chown apigee:apigee /opt/apigee/customer/application/keystore.jks
    2. Utwórz plik właściwości: 
      sudo vi /opt/apigee/customer/application/management-server.properties

      3. Zastąp wartość KEY_PASS_PHRASE hasłem do magazynu kluczy, jak pokazano poniżej: 

      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. Aby zastosować zmiany, ponownie uruchom serwer zarządzający: 
      /opt/apigee/apigee-service/bin/apigee-service edge-management-server restart
    4. Sprawdź, czy HTTPS działa lokalnie: 
      curl -u "opdk@apigee.com:Apigee123!" "https://localhost:8443/v1/users" -k
    5. Na kliencie otwórz w przeglądarce stronę https://apigeetest.com:8443/v1/users. Wpisz nazwę użytkownika i hasło administratora, aby potwierdzić, że dane logowania są prawidłowo skonfigurowane.

    Co dalej?