Halaman ini diterjemahkan oleh Cloud Translation API.

Menginstal Apigee di Google Distributed Cloud dengan air gap

Panduan ini menjelaskan cara menginstal dan men-deploy Apigee Edge untuk Private Cloud dan proxy API di lingkungan Google Distributed Cloud (GDC) yang terisolasi dari internet. Penawaran GDC air-gapped, termasuk Apigee Edge untuk Private Cloud, tidak memerlukan konektivitas ke Google Cloud untuk mengelola infrastruktur dan layanan. Anda dapat menggunakan bidang kontrol lokal yang dihosting di lokasi Anda untuk semua operasi. Untuk ringkasan GDC dengan air gap, lihat ringkasan.

Panduan ini ditujukan untuk operator Apigee yang sudah memahami Apigee Edge untuk Private Cloud dan memiliki pemahaman dasar tentang Kubernetes.

Ringkasan langkah-langkah yang diperlukan

Untuk menginstal dan men-deploy Apigee Edge untuk Private Cloud di lingkungan GDC yang terisolasi, operator harus menyelesaikan langkah-langkah berikut:

Dapatkan file penginstalan untuk Apigee Edge untuk Private Cloud.
Siapkan bucket penyimpanan.
Siapkan node repositori.
Deploy node Apigee.
Siapkan node kontrol.
Konfigurasi Ansible.
Instal komponen Apigee.
Deploy pod dan layanan.
Perbarui IP pengupload dan penerus Fluent Bit.
Lakukan aktivasi organisasi Apigee.
Uji konektivitas HTTP.
Konfigurasi TLS dan uji HTTPS.

Sebelum memulai

Sebelum memulai proses penginstalan, pastikan untuk menyelesaikan langkah-langkah berikut:

Buat project GDC untuk digunakan dalam penginstalan, jika Anda belum memilikinya. Untuk mengetahui informasi selengkapnya, lihat Membuat project.
Download, instal, dan konfigurasi CLI gdcloud di workstation yang terhubung ke GDC atau dalam lingkungan deployment berkelanjutan organisasi Anda.
Dapatkan kredensial yang diperlukan untuk menggunakan gdcloud CLI dan kubectl API. Lihat Mengautentikasi akun Anda untuk mendapatkan akses untuk mengetahui langkah-langkah yang diperlukan.
Konfirmasi nama pengguna dan sandi Apigee yang Anda terima dari pengelola akun Apigee Anda.
Konfirmasi nama cluster admin GKE dan nama cluster pengguna GKE Anda.

Persyaratan kapasitas

Menginstal Apigee Edge untuk Private Cloud di GDC memerlukan beberapa virtual machine (VM) dengan alokasi resource tertentu. VM ini dikenai biaya berdasarkan resource komputasinya (RAM, core vCPU) dan penyimpanan disk lokal. Untuk mengetahui informasi selengkapnya, lihat Harga.

Tabel berikut menunjukkan persyaratan resource untuk setiap VM:

Jenis VM	RAM	Core vCPU	Penyimpanan disk
Node repo	8 GB	Inti 2 vCPU	64 GB
Node kontrol	8 GB	Inti 2 vCPU	64 GB
Node pengelolaan API Apigee 1, 2, dan 3	RAM 16 GB	8 core vCPU	670 GB
Node pengelolaan API Apigee 4 dan 5	RAM 16 GB	8 core vCPU	500 GB - 1TB

Peran dan izin

Peran dan izin berikut diperlukan untuk men-deploy Apigee Edge untuk Private Cloud di lingkungan GDC dengan air gap:

Administrator Platform (PA): Tetapkan peran IAM Admin.
Operator Aplikasi (AO): Tetapkan peran berikut:
- Harbor Instance Admin: Memiliki akses penuh untuk mengelola instance Harbor dalam project.
- LoggingTarget Creator: Membuat resource kustom LoggingTarget di namespace project.
- LoggingTarget Editor: Mengedit resource kustom LoggingTarget di namespace project.
- Project Bucket Admin: Mengelola bucket penyimpanan dan objek dalam bucket
- Project Grafana Viewer: Mengakses instance pemantauan di namespace project.
- Project NetworkPolicy Admin: Mengelola kebijakan jaringan project di namespace project.
- Project VirtualMachine Admin: Mengelola virtual machine di namespace project.
- Secret Admin: Mengelola secret Kubernetes dalam project.
- Service Configuration Admin: Memiliki akses baca dan tulis ke konfigurasi layanan dalam namespace project.
- Namespace Admin: Mengelola semua resource dalam namespace project.

Untuk mempelajari lebih lanjut cara memberikan peran dan izin GDC air-gapped, lihat Memberikan dan mencabut akses.

Batasan

Batasan berikut berlaku untuk Apigee yang terisolasi dari internet di GDC:

Apigee di GDC yang terisolasi tidak dilengkapi dengan server DNS dan menggunakan resolusi DNS lokal sebagai solusi. Jika Apigee yang diisolasi dari internet di GDC di-deploy di lingkungan dengan server DNS eksternal, ganti langkah-langkah yang mengonfigurasi DNS lokal dengan mengonfigurasi entri DNS di server DNS.
Apigee yang diisolasi dari internet di GDC tidak menyertakan server SMTP mandiri. Anda dapat mengonfigurasi server SMTP kapan saja untuk mengaktifkan pemberitahuan email keluar untuk pembuatan akun dan reset sandi dari Server Pengelolaan dan UI Pengelolaan. Management API tetap tersedia untuk pengelolaan akun pengguna Apigee. Lihat Mengonfigurasi server SMTP Edge untuk mengetahui informasi selengkapnya.
Apigee dengan air gap di GDC tidak menerapkan deteksi dan pencegahan penyusupan. Instal dan konfigurasi Intrusion Prevention System (IPS), seperti Snort, untuk mendeteksi dan mencegah aktivitas berbahaya.

Mendapatkan file yang diperlukan

Untuk mendapatkan file penginstalan, Anda harus menyiapkan node yang terhubung terlebih dahulu, lalu mendownload file.

Menyiapkan node yang terhubung

Node yang terhubung adalah VM tunggal di luar GDC yang Anda gunakan untuk mendownload file penginstalan. VM ini memerlukan akses internet dan hanya digunakan untuk proses penginstalan.

Node yang terhubung memerlukan kapasitas dan konfigurasi berikut:

Sistem Operasi: Rocky Linux 8
Ukuran mesin: RAM 8 GB; 2 core vCPU; penyimpanan disk lokal 64 GB
Konektivitas:
- Ingress: TCP 22 (SSH)
- Egress: Internet

Untuk membuat node yang terhubung, ikuti petunjuk di Membuat dan memulai instance VM. Setelah VM dibuat, ikuti petunjuk di Menghubungkan ke VM Linux. untuk terhubung ke VM. Lihat Sistem operasi yang didukung GDC untuk mengetahui daftar sistem operasi yang didukung.

Mendownload file penginstalan

Untuk mendownload file penginstalan:

Periksa catatan rilis Apigee Edge untuk Private Cloud untuk mengetahui versi rilis resmi terbaru yang didukung untuk GDC, seperti yang tercantum dalam kolom Edge untuk Private Cloud.
Download file penyiapan Edge:
```
curl https://software.apigee.com/apigee/tarball/VERSION/rocky8/archive.tar -o /tmp/archive.tar -u 'APIGEE_USER:APIGEE_PASSWORD'
```
Dengan:
- APIGEE_USER adalah nama pengguna yang Anda terima untuk organisasi Apigee.
- APIGEE_PASSWORD adalah sandi yang Anda terima untuk organisasi Apigee.
- VERSION adalah versi rilis Apigee Edge untuk Private Cloud yang akan digunakan di GDC yang akan Anda instal, misalnya, 4.53.01.
Download file bootstrap_VERSION.sh Apigee Edge untuk Private Cloud terbaru ke /tmp/bootstrap_VERSION.sh:
```
curl https://software.apigee.com/bootstrap_VERSION.sh -o /tmp/bootstrap_VERSION.sh
```
Dengan VERSION adalah versi rilis Apigee Edge for Private Cloud terbaru untuk digunakan di GDC yang ingin Anda instal, misalnya, 4.53.01.
Instal utilitas dan dependensi Edge apigee-service:
```
sudo bash /tmp/bootstrap_VERSION.sh apigeeuser=APIGEE_USER apigeepassword=APIGEE_PASSWORD
```
Dengan:
- APIGEE_USER adalah nama pengguna yang Anda terima untuk organisasi Apigee.
- APIGEE_PASSWORD adalah sandi yang Anda terima untuk organisasi Apigee.
- VERSION adalah versi rilis Apigee Edge untuk Private Cloud yang akan digunakan di GDC yang akan Anda instal.
Jalankan skrip penyiapan di node yang terhubung:
```
chmod a+x connected-node_setup.sh \
  ./connected-node_setup.sh
```
Pada langkah ini, skrip membuat file yang diperlukan di lokasi berikut (misalnya, untuk versi 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

Transfer file yang diperlukan dari node yang terhubung ke komputer lokal melalui 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

Dengan:

SSH_PRIVATE_KEY_FILE adalah jalur ke file kunci pribadi SSH.
USER adalah nama pengguna untuk node yang terhubung.
CONNECTED_NODE_IP adalah alamat IP node yang terhubung.

Siapkan bucket penyimpanan

Pada langkah ini, operator GDC menyiapkan bucket penyimpanan di project GDC untuk menyimpan file cadangan Apigee Edge untuk Private Cloud.

Membuat bucket penyimpanan

Untuk membuat bucket penyimpanan di project GDC:

Lakukan autentikasi dengan cluster admin org:
```
gdcloud auth login --login-config-cert WEB_TLS_CERT
gdcloud clusters get-credentials ORG_ADMIN_CLUSTER
```
Dengan:
- WEB_TLS_CERT adalah jalur ke sertifikat TLS web.
- ORG_ADMIN_CLUSTER adalah nama cluster GKE admin org.
Tetapkan variabel lingkungan project dan bucket:
```
export PROJECT=PROJECT
export BUCKET=BUCKET_NAME
```
Dengan:
- PROJECT adalah nama project GDC Anda.
- BUCKET_NAME adalah nama bucket yang ingin Anda buat untuk menyimpan file cadangan Apigee Edge untuk Private Cloud.

Terapkan konfigurasi 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

Konfigurasi ini membuat bucket dengan periode retensi 30 hari.

Mengonfigurasi akses bucket

Untuk mengonfigurasi akses ke bucket penyimpanan:

Buat akun layanan di project:

gdcloud iam service-accounts create $BUCKET-sa \
    --project=$PROJECT

Buat peran dan binding peran untuk membuat secret guna mengakses 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

Dapatkan ID kunci akses dan kunci dari rahasia:

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']}")"

Output-nya akan terlihat seperti berikut:

access-key-id=RFdJMzRROVdWWjFYNTJFTzJaTk0=
access-key=U3dSdm5FRU5WdDhMckRMRW1QRGV0bE9MRHpCZ0Ntc0cxVFJQdktqdg==

Buat secret yang akan digunakan oleh pengupload di cluster GKE pengguna:
1. Lakukan autentikasi dengan cluster GKE pengguna:
```
gdcloud clusters get-credentials USER_CLUSTER
```
  Dengan USER_CLUSTER adalah nama cluster GKE pengguna.
2. Terapkan konfigurasi 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
```
  Dengan:
  - ACCESS_KEY_ID adalah ID kunci akses yang diperoleh pada langkah sebelumnya.
  - ACCESS_KEY adalah kunci akses yang diperoleh pada langkah sebelumnya.

Dapatkan endpoint penyimpanan, nama domain yang sepenuhnya memenuhi syarat (FQDN), dan region bucket:

Lakukan autentikasi dengan cluster admin org:
```
gdcloud clusters get-credentials ORG_ADMIN_CLUSTER
```
Dengan ORG_ADMIN_CLUSTER adalah nama cluster GKE admin org.

Dapatkan endpoint penyimpanan, nama domain yang sepenuhnya memenuhi syarat (FQDN), dan region bucket:

kubectl get buckets ${BUCKET} -n $PROJECT -o jsonpath="{'endpoint: '}{.status.endpoint}{'\n'}{'bucket: '}{.status.fullyQualifiedName}{'\n'}{'region: '}{.status.region}{'\n'}"

Output-nya akan terlihat seperti berikut:

endpoint: https://objectstorage.gpu-org.cookie.sesame.street
bucket: ez9wo-apigee-backup-bucket
region: cookie

Perbarui nilai berikut dalam file apigee/helm_user_cluster/values-cookie-air-gapped.yaml:
```
objectstorekeyname: "apigee-backup-bucket-secret"
objectstoreurl: "BUCKET_ENDPOINT"
objectstorebucket: "BUCKET_FQDN"
```
Dengan:
- BUCKET_ENDPOINT adalah endpoint bucket yang diperoleh pada langkah sebelumnya.
- BUCKET_FQDN adalah nama domain yang sepenuhnya memenuhi syarat dari bucket yang diperoleh pada langkah sebelumnya.

Menyiapkan node repositori

Pada langkah ini, operator GDC menyiapkan node repositori untuk menghosting repositori mirror Apigee Edge untuk Private Cloud.

Membuat node repositori

Untuk membuat node repositori:

Update apigee/helm_user_cluster/values-cookie-air-gapped.yaml sebagai berikut:
```
repo_node:
  enabled: true

apigee_node:
  enabled: false

control_node:
  enabled: false
```
Pastikan repo_node diaktifkan dan apigee_node serta control_node dinonaktifkan. Node ini akan di-deploy pada langkah selanjutnya.
Dapatkan kredensial untuk cluster admin org:
```
gdcloud clusters get-credentials ORG_ADMIN_CLUSTER
```
Dengan ORG_ADMIN_CLUSTER adalah nama cluster GKE admin org.

Buat lingkungan virtual Python:

python3 -m venv venv /
source venv/bin/activate

Jalankan skrip deployment untuk membuat node repositori:
```
python apigee/solution_deploy.py gdc-air-gapped
```

Mengonfigurasi akses node repositori

Untuk mengonfigurasi akses ke node repositori:

Konfigurasi SSH untuk node repositori:

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

Dengan SSH_PUBLIC_KEY_FILE adalah nama file yang berisi kunci SSH publik Anda.

Dapatkan alamat IP eksternal untuk node repositori:

kubectl get virtualmachineexternalaccess -n $PROJECT $NODE -ojsonpath='{.status.ingressIP}'

Dapatkan alamat IP internal untuk node repositori:

kubectl get virtualmachines.virtualmachine.gdc.goog -n $PROJECT $NODE -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

Mengupload file penginstalan

Pada langkah ini, operator GDC mengupload versi terbaru file berikut ke node repositori:

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

Untuk mengupload file penginstalan:

Salin file kunci pribadi SSH ke node repositori:
```
scp -i SSH_PRIVATE_KEY_FILE ~/apigee-files/* admin@REPO_EXTERNAL_IP:/tmp
```
Dengan:
- SSH_PRIVATE_KEY_FILE adalah nama file yang berisi kunci SSH pribadi Anda.
- REPO_EXTERNAL_IP adalah alamat IP eksternal node repositori yang diperoleh pada langkah sebelumnya.
Upload folder yang berisi konfigurasi Fluent Bit ke node repositori:
```
scp -i SSH-PRIVATE-KEY-FILE -r apigee/scripts/fluent-bit admin@REPO_EXTERNAL_IP:/tmp/fluent-bit
```
Dengan:
- SSH_PRIVATE_KEY_FILE adalah nama file yang berisi kunci SSH pribadi Anda.
- REPO_EXTERNAL_IP adalah alamat IP eksternal node repositori.

Mengonfigurasi repositori mirror

Untuk mengonfigurasi repositori cermin:

Salin apigee/scripts/repo_setup.sh ke node repositori.
Dalam skrip, ganti REPO_USER dan REPO_PASSWORD dengan nama pengguna dan sandi yang diinginkan untuk repositori mirror.
Jalankan skrip:
```
chmod a+x repo_setup.sh
./repo_setup.sh
```
Jika Anda mengalami error No such file or directory, jalankan kembali skrip.

Uji koneksi ke repositori cermin secara lokal dari node repositori.

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

Ganti VERSION dengan versi Apigee Edge untuk Private Cloud yang ingin Anda instal.

Deploy node Apigee

Pada langkah ini, operator GDC men-deploy node pengelolaan API Apigee.

Membuat node Apigee

Untuk membuat node pengelolaan API Apigee:

Ganti REPO_INTERNAL_IP, REPO_USER_NAME, dan REPO_PASSWORD di apigee/helm/scripts/apigee_setup.sh dengan nilai yang diinginkan.

Ekspor nilai sebagai variabel lingkungan:

export REPO_IP=REPO_INTERNAL_IP
export REPO_USER=REPO_USER_NAME
export REPO_PASSWORD=REPO_PASSWORD

Aktifkan apigee_node di apigee/helm/values-cookie-air-gapped.yaml seperti yang ditunjukkan::
```
apigee_node:
  enabled: true
```

Jalankan skrip deployment untuk membuat node Apigee:

  source venv/bin/activate
  python apigee/solution_deploy.py gdc-air-gapped

Mengonfigurasi akses node Apigee

Mengonfigurasi akses ke node pengelolaan API Apigee:

Lakukan autentikasi dengan cluster admin org:
```
gdcloud clusters get-credentials ORG_ADMIN_CLUSTER
```
Dengan ORG_ADMIN_CLUSTER adalah nama cluster GKE admin org.

Buat kunci SSH untuk setiap node:

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

Dengan SSH_PUBLIC_KEY_FILE adalah nama file yang berisi kunci SSH publik Anda.

Dapatkan alamat IP eksternal untuk node Apigee:

for i in 1 2 3 4 5; do
  kubectl get virtualmachineexternalaccess -n $PROJECT node$i -ojsonpath='{.status.ingressIP}'
  echo
  done

Dapatkan alamat IP internal untuk node 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

(Opsional) Periksa apakah skrip startup berhasil dijalankan di node Apigee:

SSH ke node dan jalankan perintah berikut:
```
sudo journalctl -u cloud-final -f
```

Cari log yang mirip dengan berikut ini:

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

Menyiapkan node kontrol

Pada langkah ini, operator GDC menyiapkan node kontrol untuk mengelola penginstalan Apigee.

Buat node kontrol

Untuk membuat node kontrol:

Ganti REPO_INTERNAL_IP, REPO_USER_NAME, dan REPO_PASSWORD di apigee/helm/scripts/control_setup.sh dengan nilai yang diinginkan.
Aktifkan control_node di apigee/helm/values-cookie-air-gapped.yaml seperti yang ditunjukkan:
```
control_node:
  enabled: true
```

Jalankan skrip deployment untuk membuat node kontrol:

source venv/bin/activate
python apigee/solution_deploy.py gdc-air-gapped

Mengonfigurasi akses node kontrol

Untuk mengonfigurasi akses node kontrol:

Mengonfigurasi akses SSH ke node kontrol:

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

Dapatkan alamat IP eksternal untuk node kontrol:

kubectl get virtualmachineexternalaccess -n $PROJECT control -ojsonpath='{.status.ingressIP}'

Dapatkan IP internal untuk node kontrol:

kubectl get virtualmachines.virtualmachine.GDC.goog -n $PROJECT control -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

Konfigurasi Ansible

Pada langkah ini, operator GDC menyiapkan lingkungan di node kontrol.

Untuk mengonfigurasi lingkungan Ansible:

SSH ke node kontrol dan siapkan lingkungan Ansible:

cd /home/admin
cp -r /tmp/apigee-repos .
cd apigee-repos/ansible-opdk-accelerator/setup

Mengganti repositori Git jarak jauh dengan file lokal:

sed -i 's/https:\/\/github.com\/carlosfrias/git+file:\/\/\/home\/admin\/apigee-repos/g'  requirements.yml
sed -i 's/\.git$//g'  requirements.yml

Install Ansible requirements:

  sudo chown -R admin /home/admin/apigee-repos
  ansible-galaxy install -r requirements.yml -f

Perbarui konfigurasi penyiapan:
1. Edit file main.yml:
```
vi ~/apigee-repos/ansible-opdk-accelerator/setup/roles/apigee-opdk-setup-ansible-controller/tasks/main.yml
```
2. Hapus tugas yang memerlukan akses GitHub:
  - Checkout SSH Git dari repositori konfigurasi
  - Checkout HTTPS Git untuk repositori konfigurasi
3. Jalankan playbook penyiapan:
```
cd ~/apigee-repos/ansible-opdk-accelerator/setup
ansible-playbook setup.yml
```
Upload kunci SSH untuk node Apigee ke node kontrol:
```
scp -i CONTROL_SSH_PRIVATE_KEY_FILE APIGEE_NODE_SSH_PRIVATE_KEY_FILE admin@CONTROL_EXTERNAL_IP:/home/admin/.ssh/id_rsa
```
Dengan:
- CONTROL_SSH_PRIVATE_KEY_FILE adalah nama file yang berisi kunci pribadi SSH node kontrol Anda.
- APIGEE_NODE_SSH_PRIVATE_KEY_FILE adalah nama file yang berisi kunci pribadi SSH node Apigee Anda.
- CONTROL_EXTERNAL_IP adalah alamat IP eksternal node kontrol.
Buat file konfigurasi inventaris Ansible:
1. Salin konten file apigee/scripts/ansible/prod.cfg ke file prod.cfg:
```
vi ~/.ansible/multi-planet-configurations/prod.cfg
```
2. Buat folder edge-dc1 dan salin konten file apigee/scripts/ansible/edge-dc1 ke file edge-dc1:
```
mkdir ~/.ansible/inventory/prod
vi ~/.ansible/inventory/prod/edge-dc1
```

Perbarui alamat IP internal node Apigee di 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

Dengan nilai untuk APIGEE_NODE*_INTERNAL_IP adalah alamat IP internal node Apigee yang diperoleh pada langkah sebelumnya.

Konfigurasi file ~/.apigee-secure/credentials.yml dengan nilai berikut:
- 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'
Dengan:
- APIGEE_REPO_USER adalah nama pengguna untuk repositori Apigee.
- APIGEE_REPO_PASSWORD adalah sandi untuk repositori Apigee.
- OPDK_QPID_MGMT_USERNAME adalah nama pengguna untuk server pengelolaan QPID Apigee.
- OPDK_QPID_MGMT_PASSWORD adalah sandi untuk server pengelolaan Apigee QPID.
Tambahkan file lisensi dengan file lisensi Apigee Edge untuk Private Cloud yang valid. Nama file harus license.txt.
Salin konten file ~/.apigee-secure/license.txt ke license.txt yang baru saja Anda buat.
Konfigurasi nilai berikut dalam file ~/.apigee/custom-properties.yml:
- opdk_version: 'OPDK_VERSION'
- apigee_repo_url: 'APIGEE_REPO_URL'
Dengan:
- OPDK_VERSION adalah versi Apigee Edge untuk Private Cloud yang ingin Anda instal.
- APIGEE_REPO_URL adalah URL repositori Apigee.

Ekspor file konfigurasi sebagai variabel lingkungan:

export ANSIBLE_CONFIG=~/.ansible/multi-planet-configurations/prod.cfg

Menginstal komponen Apigee

Pada langkah ini, operator GDC menginstal komponen Apigee menggunakan Ansible.

Untuk menginstal komponen Apigee:

Ganti repositori git jarak jauh dengan file lokal:

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

Instal persyaratan Ansible:

ansible-galaxy install -r requirements.yml -f

Patch peran 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

Ganti konten file install.yml dengan konten di apigee/scripts/ansible/install.yml.
Jalankan playbook untuk menginstal komponen Apigee:
```
ansible-playbook install.yml
```
Nonaktifkan link reset sandi pengguna di UI Edge. Apigee dengan air gap di GDC tidak mencakup server SMTP. Ikuti langkah-langkah di Menonaktifkan link reset sandi di UI Edge.

Men-deploy pod dan layanan

Pada langkah ini, Anda akan men-deploy pod dan layanan uploader, proxy terbalik, load balancer, dan logging.

Untuk men-deploy pod dan layanan:

Ikuti petunjuk di Membuat instance registry Harbor untuk membuat instance Harbor di project GDC dev-apigee.
Ikuti petunjuk di Create Harbor projects untuk membuat project Harbor bernama apigee.

Catatan: Jika Anda memilih nama yang berbeda untuk project GDC dan project Harbor, perbarui nilai berikut di apigee/apigee_user_cluster.toml sebagaimana mestinya:

artifact_registry_url = "harbor-1-GDC_PROJECT_ID.gpu-org.cookie.sesame.street/HARBOR_PROJECT_NAME"
...
namespace = "GDC_PROJECT_ID"

Ikuti petunjuk di Mengonfigurasi kontrol akses untuk menyiapkan kontrol akses untuk project Harbor.
Ikuti petunjuk di Login ke Docker dan Helm untuk mengonfigurasi autentikasi Docker.
Perbarui alamat IP dalam file apigee/apigee_user_cluster.toml seperti yang ditunjukkan:
```
mgmt-server-proxy = "APIGEE_NODE1_EXTERNAL_IP"
router-proxy1 = "APIGEE_NODE2_EXTERNAL_IP"
router-proxy2 = "APIGEE_NODE3_EXTERNAL_IP"
```
Dengan:
- APIGEE_NODE1_EXTERNAL_IP adalah alamat IP eksternal node1 Apigee yang diperoleh pada langkah sebelumnya.
- APIGEE_NODE2_EXTERNAL_IP adalah alamat IP eksternal node2 Apigee yang diperoleh pada langkah sebelumnya.
- APIGEE_NODE3_EXTERNAL_IP adalah alamat IP eksternal node3 Apigee yang diperoleh pada langkah sebelumnya.
Tempatkan file sertifikat SSL (server.crt) dan file kunci (server.key) untuk mengonfigurasi HTTPS di folder apigee/mgmt-server-proxy dan apigee/router-proxy.
Untuk membuat sertifikat yang ditandatangani sendiri, gunakan perintah berikut:
```
openssl req -newkey rsa:4096 -x509 -nodes -keyout server.key -new -out server.crt -subj "/CN=*.apigeetest.com" -sha256 -days 365
```
Perbarui nilai SSH-PASSWORD untuk pengguna root di penampung uploader dalam file apigee/uploader/Dockerfile:
```
RUN echo 'root:SSH_PASSWORD' | chpasswd
```
Dapatkan kredensial untuk cluster pengguna:
```
gdcloud clusters get-credentials USER_CLUSTER
```
Dengan USER_CLUSTER adalah nama cluster GKE pengguna.

Jalankan skrip deployment untuk men-deploy pod dan layanan:

source venv/bin/activate
python apigee/solution_deploy_user_cluster.py gdc-air-gapped

Dapatkan alamat IP eksternal layanan:
```
kubectl get svc -n $PROJECT_ID
```

Memperbarui IP uploader dan penerus Fluent Bit

Pada langkah ini, Anda akan memperbarui IP pengupload dan penerusan Fluent Bit dalam skrip penyiapan Apigee dan pencadangan.

Perbarui SSH_PASSWORD, root, dan UPLOADER_EXTERNAL_IP di 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/
```
Dengan:
- SSH_PASSWORD adalah sandi untuk pengguna root.
- UPLOADER_EXTERNAL_IP adalah alamat IP eksternal layanan uploader yang diperoleh pada langkah sebelumnya.
Perbarui FLUENTBIT_EXTERNAL_IP di apigee/helm/scripts/apigee_setup.sh:
```
export FLUENTBIT_EXTERNAL_IP=FLUENTBIT_EXTERNAL_IP
```

Mengupdate skrip startup memerlukan restart node Apigee. Untuk memulai ulang node:

Hentikan 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

Deploy ulang diagram Helm:

python apigee/solution_deploy.py gdc-air-gapped

Mulai VM:

for i in 1 2 3 4 5; do
  GDCloud compute instances start node$i --project $PROJECT
  done

Mengaktifkan organisasi Apigee

Pada langkah ini, operator GDC mengaktifkan organisasi Apigee dengan menjalankan skrip penyiapan di node1.

Untuk mengaktifkan organisasi Apigee:

Perbarui nilai berikut di apigee/scripts/apigee_org_setup.sh seperti yang ditunjukkan. Perbarui parameter lainnya sesuai kebutuhan.
```
IP1=APIGEE_NODE1_INTERNAL_IP

VHOST_ALIAS="APIGEE_NODE2_EXTERNAL_IP:9001 APIGEE_NODE3_EXTERNAL_IP:9001"
```
Dengan:
- APIGEE_NODE1_INTERNAL_IP adalah alamat IP internal node1 Apigee yang diperoleh pada langkah sebelumnya.
- APIGEE_NODE2_EXTERNAL_IP adalah alamat IP eksternal node2 Apigee yang diperoleh pada langkah sebelumnya.
- APIGEE_NODE3_EXTERNAL_IP adalah alamat IP eksternal node3 Apigee yang diperoleh pada langkah sebelumnya.

Jalankan skrip di node1 untuk mengaktifkan organisasi:

chmod a+x apigee_org_setup.sh
./apigee_org_setup.sh

Menguji konektivitas HTTP

Pada langkah ini, Anda akan menguji konektivitas HTTP untuk Management API dan proxy API.

Untuk menguji konektivitas HTTP:

Dapatkan alamat IP eksternal layanan apigee-elb:
```
gdcloud clusters get-credentials USER_CLUSTER
export PROJECT=dev-apigee
kubectl get svc apigee-elb -n $PROJECT
```
Dengan USER_CLUSTER adalah nama cluster GKE pengguna.

Layanan ini berfungsi sebagai endpoint untuk Edge UI, Management API, dan proxy API.

Menguji Management API

Untuk menguji Management API, kirim permintaan HTTP ke endpoint:

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

Dengan:

APIGEE_ELB_EXTERNAL_IP adalah alamat IP eksternal layanan apigee-elb yang diperoleh pada langkah sebelumnya.
ORG_NAME adalah nama organisasi Apigee.
ENV_NAME adalah nama lingkungan Apigee.

Menguji proxy API

Untuk menguji proxy API:

Login ke UI Edge.
Di halaman API Proxies, klik Create untuk membuat proxy API baru.
Di halaman Detail proxy, masukkan nilai berikut:
- Jenis proxy: Pilih Tidak ada target.
- Nama proxy: ok
- Jalur dasar: /ok
- Target: http://APIGEE_ELB_EXTERNAL_IP:9001
Klik Buat untuk membuat proxy API.

Kirim permintaan HTTP ke /ok:

curl -i http://APIGEE_ELB_EXTERNAL_IP:9001/ok

Pastikan responsnya adalah 200 OK.

Mengonfigurasi TLS dan menguji HTTPS

Pada langkah ini, operator GDC mengonfigurasi Transport Layer Security (TLS) untuk proxy API, Edge UI, dan Management API.

Mengonfigurasi TLS untuk proxy API

Ikuti langkah-langkah di Membuat keystore/truststore dan alias untuk membuat sertifikat yang ditandatangani sendiri dengan nilai berikut:
- KeyStore: myTestKeystore
- KeyAlias: myKeyAlias
- Nama Umum: apigeetest.com

Buat panggilan API untuk membuat host virtual bernama 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>'

Dengan:

APIGEE_ELB_EXTERNAL_IP adalah alamat IP eksternal layanan apigee-elb yang diperoleh pada langkah sebelumnya.
ORG_NAME adalah nama organisasi Apigee.
ENV_NAME adalah nama lingkungan Apigee tempat host virtual harus dibuat.

Buat proxy API menggunakan host virtual yang aman.

Di router, konfigurasi resolusi DNS untuk host virtual:

echo '127.0.0.1 api.apigeetest.com' | sudo tee -a /etc/hosts

Pastikan host virtual berfungsi secara lokal dengan mengirim permintaan HTTPS ke endpoint:
```
curl https://api.apigeetest.com:9005/ok -v -k
```
Konfigurasi resolusi DNS untuk endpoint:
```
echo 'APIGEE_ELB_EXTERNAL_IP apigeetest.com' | sudo tee -a /etc/hosts
```
Dengan APIGEE_ELB_EXTERNAL_IP adalah alamat IP eksternal layanan apigee-elb yang diperoleh pada langkah sebelumnya.
Buka https://apigeetest.com/ok di browser web dan pastikan aplikasi berfungsi.

Mengonfigurasi TLS untuk UI Edge

Untuk mengonfigurasi TLS bagi Edge UI:

Buat file keystore dari file sertifikat SSL dan file kunci:

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

Tempatkan file keystore di folder Apigee di node1:
```
scp -i SSH_PRIVATE_KEY_FILE keystore.jks admin@APIGEE_NODE1_EXTERNAL_IP:/home/admin/
```
Dengan:
- SSH_PRIVATE_KEY_FILE adalah nama file yang berisi kunci pribadi SSH node Apigee Anda.
- APIGEE_NODE1_EXTERNAL_IP adalah alamat IP eksternal node1 Apigee yang diperoleh pada langkah sebelumnya.
Gunakan SSH ke node1 dan pindahkan file keystore ke folder Apigee:
```
sudo mv keystore.jks /opt/apigee/customer/application/
```
Buat file konfigurasi SSL:
```
sudo vi /tmp/sslConfigFile
```

Perbarui nilai KEY-PASS-PHRASE seperti yang ditunjukkan:

HTTPSPORT=9443
DISABLE_HTTP=n
KEY_ALGO=JKS
KEY_FILE_PATH=/opt/apigee/customer/application/keystore.jks
KEY_PASS=KEY_PASS_PHRASE

Mengonfigurasi SSL menggunakan file konfigurasi:

sudo chown apigee:apigee /tmp/sslConfigFile
/opt/apigee/apigee-service/bin/apigee-service edge-ui configure-ssl -f /tmp/sslConfigFile

Konfigurasi resolusi DNS untuk UI Edge:
```
echo 'APIGEE_ELB_EXTERNAL_IP ui.apigeetest.com' | sudo tee -a /etc/hosts
```
Dengan APIGEE_ELB_EXTERNAL_IP adalah alamat IP eksternal layanan apigee-elb yang diperoleh pada langkah sebelumnya.
Akses https://ui.apigeetest.com:9443 di browser web dan pastikan aplikasi berfungsi. Untuk mengetahui detail selengkapnya, lihat panduan.

Mengonfigurasi TLS untuk Management API

Untuk mengonfigurasi TLS untuk Management API:

Konfigurasi pemilik untuk file keystore (gunakan yang sama dengan Edge UI):
```
sudo chown apigee:apigee /opt/apigee/customer/application/keystore.jks
```

Buat file properti:

sudo vi /opt/apigee/customer/application/management-server.properties

Ganti nilai KEY_PASS_PHRASE dengan sandi keystore, seperti yang ditunjukkan:

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

Mulai ulang server pengelolaan agar perubahan diterapkan:

/opt/apigee/apigee-service/bin/apigee-service edge-management-server restart

Konfirmasi bahwa HTTPS berfungsi secara lokal:

curl -u "opdk@apigee.com:Apigee123!" "https://localhost:8443/v1/users" -k

Dari klien, akses https://apigeetest.com:8443/v1/users di browser. Masukkan nama pengguna dan sandi admin untuk mengonfirmasi bahwa kredensial dikonfigurasi dengan benar.

Menginstal Apigee di Google Distributed Cloud dengan air gap

Ringkasan langkah-langkah yang diperlukan

Sebelum memulai

Persyaratan kapasitas

Peran dan izin

Batasan

Mendapatkan file yang diperlukan

Menyiapkan node yang terhubung

Mendownload file penginstalan

Siapkan bucket penyimpanan

Membuat bucket penyimpanan

Mengonfigurasi akses bucket

Menyiapkan node repositori

Membuat node repositori

Mengonfigurasi akses node repositori

Mengupload file penginstalan

Mengonfigurasi repositori mirror

Deploy node Apigee

Membuat node Apigee

Mengonfigurasi akses node Apigee

Menyiapkan node kontrol

Buat node kontrol

Mengonfigurasi akses node kontrol

Konfigurasi Ansible

Menginstal komponen Apigee

Men-deploy pod dan layanan

Memperbarui IP uploader dan penerus Fluent Bit

Mengaktifkan organisasi Apigee

Menguji konektivitas HTTP

Menguji Management API

Menguji proxy API

Mengonfigurasi TLS dan menguji HTTPS

Mengonfigurasi TLS untuk proxy API

Mengonfigurasi TLS untuk UI Edge

Mengonfigurasi TLS untuk Management API

Langkah berikutnya