ติดตั้ง Apigee ใน Google Distributed Cloud ที่แยกจากอินเทอร์เน็ต

คู่มือนี้อธิบายวิธีติดตั้งและติดตั้งใช้งาน Apigee Edge สำหรับ Private Cloud และพร็อกซี API ในสภาพแวดล้อม Google Distributed Cloud (GDC) ที่แยกจากอินเทอร์เน็ต ข้อเสนอ GDC แบบแยกเครือข่าย ซึ่งรวมถึง Apigee Edge สำหรับ Private Cloud ไม่จำเป็นต้องเชื่อมต่อกับ Google Cloud เพื่อจัดการโครงสร้างพื้นฐานและบริการ คุณสามารถใช้ระนาบควบคุมในพื้นที่ที่โฮสต์ในสถานที่ของคุณสำหรับการดำเนินการทั้งหมด ดูภาพรวมของ GDC ที่แยกจากเครือข่ายภายนอกได้ที่ภาพรวม

คู่มือนี้มีไว้สำหรับผู้ปฏิบัติงาน Apigee ที่คุ้นเคยกับ Apigee Edge สำหรับ Private Cloud และมีความเข้าใจพื้นฐานเกี่ยวกับ Kubernetes

ภาพรวมของขั้นตอนที่ต้องทำ

หากต้องการติดตั้งและใช้งาน Apigee Edge สำหรับ Private Cloud ในสภาพแวดล้อม GDC ที่แยกจากอินเทอร์เน็ต ผู้ปฏิบัติงานต้องทำตามขั้นตอนต่อไปนี้

ก่อนเริ่มต้น

ก่อนเริ่มกระบวนการติดตั้ง โปรดทำตามขั้นตอนต่อไปนี้

  1. สร้างโปรเจ็กต์ GDC เพื่อใช้ในการติดตั้ง หากยังไม่มี ดูข้อมูลเพิ่มเติมได้ที่สร้างโปรเจ็กต์
  2. ดาวน์โหลด ติดตั้ง และกำหนดค่า gdcloud CLI ในเวิร์กสเตชันที่เชื่อมต่อกับ GDC หรือภายในสภาพแวดล้อมการติดตั้งใช้งานต่อเนื่องขององค์กร
  3. รับข้อมูลเข้าสู่ระบบที่จำเป็นในการใช้ gdcloudCLI และ kubectlAPI ดูขั้นตอนที่จำเป็นได้ที่ ตรวจสอบสิทธิ์บัญชีเพื่อเข้าถึง
  4. ยืนยันชื่อผู้ใช้และรหัสผ่าน Apigee ที่คุณได้รับจากผู้จัดการลูกค้า Apigee
  5. ยืนยันชื่อคลัสเตอร์ผู้ดูแลระบบ GKE และชื่อคลัสเตอร์ผู้ใช้ GKE

ข้อกำหนดด้านความจุ

การติดตั้ง Apigee Edge สำหรับ Private Cloud ใน GDC ต้องใช้เครื่องเสมือน (VM) หลายเครื่อง ที่มีการจัดสรรทรัพยากรที่เฉพาะเจาะจง VM เหล่านี้จะมีการเรียกเก็บเงินตาม ทรัพยากรการประมวลผล (RAM, คอร์ vCPU) และพื้นที่เก็บข้อมูลในดิสก์ภายใน ดูข้อมูลเพิ่มเติมได้ที่ การกำหนดราคา

ตารางต่อไปนี้แสดงข้อกำหนดของทรัพยากรสำหรับ VM แต่ละรายการ

ประเภท VM RAM แกน vCPU พื้นที่เก็บข้อมูลในดิสก์
โหนดที่เก็บ 8GB แกน vCPU 2 แกน 64 GB
โหนดควบคุม 8GB แกน vCPU 2 แกน 64 GB
โหนดการจัดการ Apigee API 1, 2 และ 3 RAM 16 GB 8-vCPU Core 670 GB
โหนดการจัดการ Apigee API 4 และ 5 RAM 16 GB 8-vCPU Core 500 GB - 1TB

บทบาทและสิทธิ์

คุณต้องมีบทบาทและสิทธิ์ต่อไปนี้เพื่อติดตั้งใช้งาน Apigee Edge สำหรับ Private Cloud ในสภาพแวดล้อม GDC ที่แยกจากอินเทอร์เน็ต

  • ผู้ดูแลระบบแพลตฟอร์ม (PA): มอบหมายIAM Admin
  • ผู้ปฏิบัติงานแอปพลิเคชัน (AO): มอบหมายบทบาทต่อไปนี้
    • Harbor Instance Admin: มีสิทธิ์เข้าถึงแบบเต็มเพื่อจัดการอินสแตนซ์ Harbor ในโปรเจ็กต์
    • LoggingTarget Creator: สร้างLoggingTargetทรัพยากรที่กำหนดเองในเนมสเปซของโปรเจ็กต์
    • LoggingTarget Editor: แก้ไขLoggingTargetทรัพยากรที่กำหนดเองในเนมสเปซของโปรเจ็กต์
    • Project Bucket Admin: จัดการที่เก็บข้อมูลและออบเจ็กต์ภายในที่เก็บข้อมูล
    • Project Grafana Viewer: เข้าถึงอินสแตนซ์การตรวจสอบในเนมสเปซของโปรเจ็กต์
    • Project NetworkPolicy Admin: จัดการนโยบายเครือข่ายของโปรเจ็กต์ในเนมสเปซของโปรเจ็กต์
    • Project VirtualMachine Admin: จัดการเครื่องเสมือนในเนมสเปซของโปรเจ็กต์
    • Secret Admin: จัดการข้อมูลลับของ Kubernetes ในโปรเจ็กต์
    • Service Configuration Admin: มีสิทธิ์การอ่านและเขียนการกำหนดค่าบริการภายในเนมสเปซของโปรเจ็กต์
    • Namespace Admin: จัดการทรัพยากรทั้งหมดภายในเนมสเปซของโปรเจ็กต์

    • ดูข้อมูลเพิ่มเติมเกี่ยวกับการให้บทบาทและสิทธิ์ GDC แบบแอร์แกปได้ที่ ให้และเพิกถอนสิทธิ์เข้าถึง

    ข้อจำกัด

    ข้อจำกัดต่อไปนี้มีผลกับ Apigee ใน GDC แบบ Air-Gap

    • Apigee ใน GDC ที่แยกเครือข่ายไม่ได้มาพร้อมกับเซิร์ฟเวอร์ DNS และใช้การแปลง DNS ในเครื่องเป็นวิธีแก้ปัญหาเฉพาะหน้า หากมีการติดตั้งใช้งาน Apigee ใน GDC แบบ Air-Gapped ในสภาพแวดล้อมที่มีเซิร์ฟเวอร์ DNS ภายนอก ให้แทนที่ขั้นตอนที่กำหนดค่า DNS ภายในด้วยการกำหนดค่ารายการ DNS ในเซิร์ฟเวอร์ DNS
    • Apigee ใน GDC ที่แยกจากอินเทอร์เน็ตไม่มีเซิร์ฟเวอร์ SMTP แบบสแตนด์อโลน คุณกำหนดค่าเซิร์ฟเวอร์ SMTP ได้ทุกเมื่อเพื่อเปิดใช้การแจ้งเตือนทางอีเมลขาออกสำหรับการสร้างบัญชีและการรีเซ็ตรหัสผ่านจากเซิร์ฟเวอร์การจัดการและ UI การจัดการ Management API จะยังคงพร้อมใช้งานสำหรับการจัดการบัญชีผู้ใช้ Apigee ดูข้อมูลเพิ่มเติมได้ที่การกำหนดค่าเซิร์ฟเวอร์ SMTP ที่ Edge
    • Apigee ใน GDC ที่แยกเครือข่ายไม่ใช้การตรวจจับและการป้องกันการบุกรุก ติดตั้งและ กำหนดค่าระบบป้องกันการบุกรุก (IPS) เช่น Snort เพื่อตรวจจับและป้องกันกิจกรรมที่เป็นอันตราย

    รับไฟล์ที่จำเป็น

    หากต้องการรับไฟล์การติดตั้ง คุณต้องตั้งค่าโหนดที่เชื่อมต่อก่อน แล้วจึงดาวน์โหลดไฟล์

    ตั้งค่าโหนดที่เชื่อมต่อ

    โหนดที่เชื่อมต่อคือ VM เดียวที่อยู่นอก GDC ซึ่งคุณใช้เพื่อดาวน์โหลดไฟล์การติดตั้ง VM นี้ต้องมีสิทธิ์เข้าถึงอินเทอร์เน็ตและใช้สำหรับกระบวนการติดตั้งเท่านั้น

    โหนดที่เชื่อมต่อต้องมีความจุและการกำหนดค่าต่อไปนี้

    • ระบบปฏิบัติการ: Rocky Linux 8
    • ขนาดเครื่อง: RAM 8 GB, 2 คอร์ vCPU, พื้นที่เก็บข้อมูลในดิสก์ภายใน 64 GB
    • การเชื่อมต่อ:
      • ขาเข้า: TCP 22 (SSH)
      • ขาออก: อินเทอร์เน็ต

    หากต้องการสร้างโหนดที่เชื่อมต่อ ให้ทำตามวิธีการใน สร้างและเริ่มต้นอินสแตนซ์ VM เมื่อสร้าง VM แล้ว ให้ทำตามวิธีการในเชื่อมต่อกับ VM ของ Linux เพื่อเชื่อมต่อกับ VM ดูรายการระบบปฏิบัติการที่รองรับได้ที่ ระบบปฏิบัติการที่ GDC รองรับ

    ดาวน์โหลดไฟล์การติดตั้ง

    วิธีดาวน์โหลดไฟล์การติดตั้ง

    1. ดูบันทึกประจำรุ่นของ Apigee Edge สำหรับ Private Cloud เพื่อดูเวอร์ชันที่เผยแพร่ล่าสุดที่รองรับ GDC ตามที่ระบุไว้ในคอลัมน์ Edge สำหรับ Private Cloud
    2. ดาวน์โหลดไฟล์การตั้งค่า Edge โดยทำดังนี้ 
      curl https://software.apigee.com/apigee/tarball/VERSION/rocky8/archive.tar -o /tmp/archive.tar -u 'APIGEE_USER:APIGEE_PASSWORD'

      สถานที่:

      • APIGEE_USER คือชื่อผู้ใช้ที่คุณได้รับสำหรับองค์กร Apigee
      • APIGEE_PASSWORD คือรหัสผ่านที่คุณได้รับสำหรับองค์กร Apigee
      • VERSION คือเวอร์ชันที่เผยแพร่ของ Apigee Edge สำหรับ Private Cloud ที่ใช้ใน GDC ที่คุณต้องการติดตั้ง เช่น 4.53.01
    3. ดาวน์โหลดไฟล์ Apigee Edge สำหรับ Private Cloud bootstrap_VERSION.sh ล่าสุดไปที่ /tmp/bootstrap_VERSION.sh 
      curl https://software.apigee.com/bootstrap_VERSION.sh -o /tmp/bootstrap_VERSION.sh

      โดย VERSION คือ Apigee Edge สำหรับ Private Cloud เวอร์ชันที่เผยแพร่ล่าสุดสำหรับการใช้งานใน GDC ที่คุณต้องการติดตั้ง เช่น 4.53.01

    4. ติดตั้งยูทิลิตีและทรัพยากร Dependency ของ Edge apigee-service โดยทำดังนี้ 
      sudo bash /tmp/bootstrap_VERSION.sh apigeeuser=APIGEE_USER apigeepassword=APIGEE_PASSWORD

      สถานที่:

      • APIGEE_USER คือชื่อผู้ใช้ที่คุณได้รับสำหรับองค์กร Apigee
      • APIGEE_PASSWORD คือรหัสผ่านที่คุณได้รับสำหรับองค์กร Apigee
      • VERSION คือเวอร์ชันที่เผยแพร่ของ Apigee Edge สำหรับ Private Cloud ที่ใช้ใน GDC ที่คุณต้องการติดตั้ง

    5. เรียกใช้สคริปต์การตั้งค่าในโหนดที่เชื่อมต่อโดยทำดังนี้ 
      chmod a+x connected-node_setup.sh \
  ./connected-node_setup.sh

      ในขั้นตอนนี้ สคริปต์จะสร้างไฟล์ที่จำเป็นในตำแหน่งต่อไปนี้ (เช่น สำหรับเวอร์ชัน 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. โอนไฟล์ที่จำเป็นจากโหนดที่เชื่อมต่อไปยังเครื่องภายในผ่าน 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

      สถานที่:

      • SSH_PRIVATE_KEY_FILE คือเส้นทางไปยังไฟล์คีย์ส่วนตัว SSH
      • USER คือชื่อผู้ใช้สำหรับโหนดที่เชื่อมต่อ
      • CONNECTED_NODE_IP คือที่อยู่ IP ของโหนดที่เชื่อมต่อ

    ตั้งค่าที่เก็บข้อมูล

    ในขั้นตอนนี้ ผู้ปฏิบัติงาน GDC จะตั้งค่าที่เก็บข้อมูลในโปรเจ็กต์ GDC เพื่อจัดเก็บไฟล์สำรองข้อมูล Apigee Edge สำหรับ Private Cloud

    สร้างที่เก็บข้อมูล

    วิธีสร้างที่เก็บข้อมูลในโปรเจ็กต์ GDC

    1. ตรวจสอบสิทธิ์ด้วยคลัสเตอร์ผู้ดูแลระบบองค์กร 
      gdcloud auth login --login-config-cert WEB_TLS_CERT
gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      สถานที่:

      • WEB_TLS_CERT คือเส้นทางไปยังใบรับรอง TLS ของเว็บ
      • ORG_ADMIN_CLUSTER คือชื่อของคลัสเตอร์ GKE ของผู้ดูแลระบบองค์กร

    2. ตั้งค่าตัวแปรสภาพแวดล้อมของโปรเจ็กต์และที่เก็บข้อมูล 
      export PROJECT=PROJECT
export BUCKET=BUCKET_NAME

      สถานที่:

      • PROJECT คือชื่อโปรเจ็กต์ GDC
      • BUCKET_NAME คือชื่อของ Bucket ที่คุณต้องการสร้างเพื่อจัดเก็บไฟล์สำรองข้อมูลของ Apigee Edge สำหรับ Private Cloud
    3. ใช้การกำหนดค่าที่เก็บข้อมูล 
      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

      การกำหนดค่านี้จะสร้าง Bucket ที่มีระยะเวลาเก็บรักษา 30 วัน

    กำหนดค่าการเข้าถึงที่เก็บข้อมูล

    วิธีกำหนดค่าการเข้าถึงที่เก็บข้อมูล

    1. สร้างบัญชีบริการในโปรเจ็กต์โดยทำดังนี้ 
      gdcloud iam service-accounts create $BUCKET-sa \
    --project=$PROJECT
    2. สร้างบทบาทและการเชื่อมโยงบทบาทเพื่อสร้างข้อมูลลับสำหรับการเข้าถึง 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. รับรหัสคีย์การเข้าถึงและคีย์จากข้อมูลลับ 
      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']}")"

      เอาต์พุตควรมีลักษณะคล้ายกับตัวอย่างต่อไปนี้ 

      access-key-id=RFdJMzRROVdWWjFYNTJFTzJaTk0=
access-key=U3dSdm5FRU5WdDhMckRMRW1QRGV0bE9MRHpCZ0Ntc0cxVFJQdktqdg==
    4. สร้าง Secret ที่อัปโหลดใช้ในคลัสเตอร์ GKE ของผู้ใช้โดยทำดังนี้
      1. ตรวจสอบสิทธิ์ด้วยคลัสเตอร์ GKE ของผู้ใช้ 
        gdcloud clusters get-credentials USER_CLUSTER

        โดยที่ USER_CLUSTER คือชื่อของคลัสเตอร์ GKE ของผู้ใช้

      2. ใช้การกำหนดค่าลับ 
        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

        สถานที่:

        • ACCESS_KEY_ID คือรหัสคีย์การเข้าถึงที่ได้รับในขั้นตอนก่อนหน้า
        • ACCESS_KEY คือคีย์การเข้าถึงที่ได้รับในขั้นตอนก่อนหน้า
    5. รับปลายทางการจัดเก็บ ชื่อโดเมนที่สมบูรณ์ในตัวเอง (FQDN) และภูมิภาคของที่เก็บข้อมูล
      1. ตรวจสอบสิทธิ์ด้วยคลัสเตอร์ผู้ดูแลระบบองค์กร 
        gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

        โดยที่ ORG_ADMIN_CLUSTER คือชื่อของคลัสเตอร์ GKE ของผู้ดูแลระบบองค์กร

      2. รับปลายทางการจัดเก็บ ชื่อโดเมนที่สมบูรณ์ในตัวเอง (FQDN) และภูมิภาคของที่เก็บข้อมูล 
        kubectl get buckets ${BUCKET} -n $PROJECT -o jsonpath="{'endpoint: '}{.status.endpoint}{'\n'}{'bucket: '}{.status.fullyQualifiedName}{'\n'}{'region: '}{.status.region}{'\n'}"

        เอาต์พุตควรมีลักษณะคล้ายกับตัวอย่างต่อไปนี้

        endpoint: https://objectstorage.gpu-org.cookie.sesame.street
bucket: ez9wo-apigee-backup-bucket
region: cookie
    6. อัปเดตค่าต่อไปนี้ในไฟล์ apigee/helm_user_cluster/values-cookie-air-gapped.yaml 
      objectstorekeyname: "apigee-backup-bucket-secret"
objectstoreurl: "BUCKET_ENDPOINT"
objectstorebucket: "BUCKET_FQDN"

      สถานที่:

      • BUCKET_ENDPOINT คือปลายทางของที่เก็บข้อมูลที่ได้รับในขั้นตอนก่อนหน้า
      • BUCKET_FQDN คือชื่อโดเมนที่สมบูรณ์ในตัวเองของที่ได้ในขั้นตอนก่อนหน้า

    ตั้งค่าโหนดที่เก็บ

    ในขั้นตอนนี้ ผู้ดูแลระบบ GDC จะตั้งค่าโหนดที่เก็บเพื่อโฮสต์ที่เก็บมิเรอร์ Apigee Edge สำหรับ Private Cloud

    สร้างโหนดที่เก็บ

    วิธีสร้างโหนดที่เก็บ

    1. อัปเดต apigee/helm_user_cluster/values-cookie-air-gapped.yaml ดังนี้ 
      repo_node:
  enabled: true

apigee_node:
  enabled: false

control_node:
  enabled: false

      ตรวจสอบว่าได้เปิดใช้ repo_node แล้ว และปิดใช้ทั้ง apigee_node และ control_node โดยจะทำให้โหนดเหล่านี้ใช้งานได้ในขั้นตอนถัดไป

    2. รับข้อมูลเข้าสู่ระบบสำหรับคลัสเตอร์ผู้ดูแลระบบองค์กรโดยทำดังนี้ 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      โดยที่ ORG_ADMIN_CLUSTER คือชื่อของคลัสเตอร์ GKE ของผู้ดูแลระบบองค์กร

    3. สร้างสภาพแวดล้อมเสมือนของ Python 
      python3 -m venv venv /
source venv/bin/activate
    4. เรียกใช้สคริปต์การติดตั้งใช้งานเพื่อสร้างโหนดที่เก็บข้อมูล 
      python apigee/solution_deploy.py gdc-air-gapped

    กำหนดค่าการเข้าถึงโหนดที่เก็บ

    วิธีกำหนดค่าการเข้าถึงโหนดที่เก็บ

    1. กำหนดค่า SSH สำหรับโหนดที่เก็บดังนี้ 
      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

      โดย SSH_PUBLIC_KEY_FILE คือชื่อไฟล์ที่มีคีย์ SSH สาธารณะ

    2. รับที่อยู่ IP ภายนอกสำหรับโหนดที่เก็บ 
      kubectl get virtualmachineexternalaccess -n $PROJECT $NODE -ojsonpath='{.status.ingressIP}'
    3. รับที่อยู่ IP ภายในสำหรับโหนดที่เก็บ 
      kubectl get virtualmachines.virtualmachine.gdc.goog -n $PROJECT $NODE -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

    อัปโหลดไฟล์การติดตั้ง

    ในขั้นตอนนี้ ผู้ปฏิบัติงาน GDC จะอัปโหลดไฟล์ต่อไปนี้เวอร์ชันล่าสุดไปยังโหนดที่เก็บ

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

    วิธีอัปโหลดไฟล์การติดตั้ง

    1. คัดลอกไฟล์คีย์ส่วนตัว SSH ไปยังโหนดที่เก็บ 
      scp -i SSH_PRIVATE_KEY_FILE ~/apigee-files/* admin@REPO_EXTERNAL_IP:/tmp

      สถานที่:

      • SSH_PRIVATE_KEY_FILE คือชื่อไฟล์ที่มีคีย์ SSH ส่วนตัว
      • REPO_EXTERNAL_IP คือที่อยู่ IP ภายนอกของโหนดที่เก็บที่ได้รับในขั้นตอนก่อนหน้า
    2. อัปโหลดโฟลเดอร์ที่มีการกำหนดค่า Fluent Bit ไปยังโหนดที่เก็บ 
      scp -i SSH-PRIVATE-KEY-FILE -r apigee/scripts/fluent-bit admin@REPO_EXTERNAL_IP:/tmp/fluent-bit

      สถานที่:

      • SSH_PRIVATE_KEY_FILE คือชื่อไฟล์ที่มีคีย์ SSH ส่วนตัว
      • REPO_EXTERNAL_IP คือที่อยู่ IP ภายนอกของโหนดที่เก็บ

    กำหนดค่าที่เก็บมิเรอร์

    วิธีกำหนดค่าที่เก็บมิเรอร์

    1. คัดลอก apigee/scripts/repo_setup.sh ไปยังโหนดที่เก็บ
    2. ในสคริปต์ ให้แทนที่ REPO_USER และ REPO_PASSWORD ด้วยชื่อผู้ใช้และรหัสผ่านที่ต้องการสำหรับที่เก็บข้อมูลมิเรอร์
    3. เรียกใช้สคริปต์ 
      chmod a+x repo_setup.sh
./repo_setup.sh

      หากพบข้อผิดพลาด No such file or directory ให้เรียกใช้สคริปต์อีกครั้ง

    4. ทดสอบการเชื่อมต่อกับที่เก็บมิเรอร์ในเครื่องจากโหนดที่เก็บ 
      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

      แทนที่ VERSION ด้วย Apigee Edge สำหรับ Private Cloud เวอร์ชันที่คุณต้องการติดตั้ง

    ติดตั้งใช้งานโหนด Apigee

    ในขั้นตอนนี้ โอเปอเรเตอร์ GDC จะติดตั้งโหนดการจัดการ API ของ Apigee

    สร้างโหนด Apigee

    วิธีสร้างโหนดการจัดการ Apigee API

    1. แทนที่ REPO_INTERNAL_IP, REPO_USER_NAME และ REPO_PASSWORD ใน apigee/helm/scripts/apigee_setup.sh ด้วยค่าที่ต้องการ
    2. ส่งออกค่าเป็นตัวแปรสภาพแวดล้อม 
      export REPO_IP=REPO_INTERNAL_IP
export REPO_USER=REPO_USER_NAME
export REPO_PASSWORD=REPO_PASSWORD
    3. เปิดใช้ apigee_node ใน apigee/helm/values-cookie-air-gapped.yaml ตามที่แสดง:: 
      apigee_node:
  enabled: true
    4. เรียกใช้สคริปต์การติดตั้งใช้งานเพื่อสร้างโหนด Apigee 
        source venv/bin/activate
  python apigee/solution_deploy.py gdc-air-gapped

    กำหนดค่าการเข้าถึงโหนด Apigee

    กำหนดค่าการเข้าถึงโหนดการจัดการ Apigee API โดยทำดังนี้

    1. ตรวจสอบสิทธิ์ด้วยคลัสเตอร์ผู้ดูแลระบบองค์กร 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      โดยที่ ORG_ADMIN_CLUSTER คือชื่อของคลัสเตอร์ GKE ของผู้ดูแลระบบองค์กร

    2. สร้างคีย์ SSH สำหรับแต่ละโหนดโดยทำดังนี้ 
      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

      โดย SSH_PUBLIC_KEY_FILE คือชื่อไฟล์ที่มีคีย์ SSH สาธารณะ

    3. รับที่อยู่ IP ภายนอกสำหรับโหนด Apigee โดยทำดังนี้ 
      for i in 1 2 3 4 5; do
  kubectl get virtualmachineexternalaccess -n $PROJECT node$i -ojsonpath='{.status.ingressIP}'
  echo
  done
    4. รับที่อยู่ IP ภายในสำหรับโหนด 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. (ไม่บังคับ) ตรวจสอบว่าสคริปต์เริ่มต้นทำงานในโหนด Apigee สำเร็จหรือไม่ โดยทำดังนี้
      1. ใช้ SSH ไปยังโหนดแล้วเรียกใช้คำสั่งต่อไปนี้ 
        sudo journalctl -u cloud-final -f
      2. มองหาบันทึกที่คล้ายกับบันทึกต่อไปนี้ 
        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

    ตั้งค่าโหนดควบคุม

    ในขั้นตอนนี้ ผู้ปฏิบัติงาน GDC จะตั้งค่าโหนดควบคุมเพื่อจัดการการติดตั้ง Apigee

    สร้างโหนดควบคุม

    วิธีสร้างโหนดควบคุม

    1. แทนที่ REPO_INTERNAL_IP, REPO_USER_NAME และ REPO_PASSWORD ใน apigee/helm/scripts/control_setup.sh ด้วยค่าที่ต้องการ
    2. เปิดใช้ control_node ใน apigee/helm/values-cookie-air-gapped.yaml ดังที่แสดง 
      control_node:
  enabled: true
    3. เรียกใช้สคริปต์การติดตั้งใช้งานเพื่อสร้างโหนดควบคุม 
      source venv/bin/activate
python apigee/solution_deploy.py gdc-air-gapped

    กำหนดค่าการเข้าถึงโหนดควบคุม

    วิธีกำหนดค่าการเข้าถึงโหนดควบคุม

    1. กำหนดค่าการเข้าถึง SSH ไปยังโหนดควบคุม 
      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. รับที่อยู่ IP ภายนอกสำหรับโหนดควบคุม 
      kubectl get virtualmachineexternalaccess -n $PROJECT control -ojsonpath='{.status.ingressIP}'
    3. รับ IP ภายในสำหรับโหนดควบคุม 
      kubectl get virtualmachines.virtualmachine.GDC.goog -n $PROJECT control -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

    กำหนดค่า Ansible

    ในขั้นตอนนี้ ผู้ปฏิบัติงาน GDC จะตั้งค่าสภาพแวดล้อม ในโหนดควบคุม

    วิธีกำหนดค่าสภาพแวดล้อม Ansible

    1. เปิดเซสชัน SSH ไปยังโหนดควบคุมและตั้งค่าสภาพแวดล้อม Ansible โดยทำดังนี้ 
      cd /home/admin
cp -r /tmp/apigee-repos .
cd apigee-repos/ansible-opdk-accelerator/setup
    2. แทนที่ที่เก็บ Git ระยะไกลด้วยไฟล์ในเครื่อง 
      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. อัปเดตการกำหนดค่าการตั้งค่า
      1. แก้ไขไฟล์ main.yml 
        vi ~/apigee-repos/ansible-opdk-accelerator/setup/roles/apigee-opdk-setup-ansible-controller/tasks/main.yml
      2. นำงานที่ต้องใช้สิทธิ์เข้าถึง GitHub ออก โดยทำดังนี้
        • การชำระเงิน SSH ของ Git สำหรับที่เก็บการกำหนดค่า
        • การชำระเงินผ่าน HTTPS ของที่เก็บการกำหนดค่า Git
      3. เรียกใช้เพลย์บุ๊กการตั้งค่า 
        cd ~/apigee-repos/ansible-opdk-accelerator/setup
ansible-playbook setup.yml
    5. อัปโหลดคีย์ SSH สำหรับโหนด Apigee ไปยังโหนดควบคุมโดยทำดังนี้ 
      scp -i CONTROL_SSH_PRIVATE_KEY_FILE APIGEE_NODE_SSH_PRIVATE_KEY_FILE admin@CONTROL_EXTERNAL_IP:/home/admin/.ssh/id_rsa

      สถานที่:

      • CONTROL_SSH_PRIVATE_KEY_FILE คือชื่อไฟล์ที่มีคีย์ส่วนตัว SSH ของโหนดควบคุม
      • APIGEE_NODE_SSH_PRIVATE_KEY_FILE คือชื่อไฟล์ที่มีคีย์ส่วนตัว SSH ของโหนด Apigee
      • CONTROL_EXTERNAL_IP คือที่อยู่ IP ภายนอกของโหนดควบคุม
    6. สร้างไฟล์การกำหนดค่าสินค้าคงคลังของ Ansible โดยทำดังนี้
      1. คัดลอกเนื้อหาของไฟล์ apigee/scripts/ansible/prod.cfg ไปยังไฟล์ prod.cfg โดยทำดังนี้ 
        vi ~/.ansible/multi-planet-configurations/prod.cfg
      2. สร้างโฟลเดอร์ edge-dc1 แล้วคัดลอกเนื้อหาของไฟล์ apigee/scripts/ansible/edge-dc1 ไปยังไฟล์ edge-dc1 โดยทำดังนี้ 
        mkdir ~/.ansible/inventory/prod
vi ~/.ansible/inventory/prod/edge-dc1
    7. อัปเดตที่อยู่ IP ภายในของโหนด Apigee ใน 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

      โดยค่าสำหรับ APIGEE_NODE*_INTERNAL_IP คือที่อยู่ IP ภายในของโหนด Apigee ที่ได้รับในขั้นตอนก่อนหน้า

    8. กำหนดค่าไฟล์ ~/.apigee-secure/credentials.yml ด้วยค่าต่อไปนี้
      • 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'

      สถานที่:

      • APIGEE_REPO_USER คือชื่อผู้ใช้สำหรับที่เก็บ Apigee
      • APIGEE_REPO_PASSWORD คือรหัสผ่านสำหรับที่เก็บ Apigee
      • OPDK_QPID_MGMT_USERNAME คือชื่อผู้ใช้สำหรับเซิร์ฟเวอร์การจัดการ Apigee QPID
      • OPDK_QPID_MGMT_PASSWORD คือรหัสผ่านสำหรับเซิร์ฟเวอร์การจัดการ QPID ของ Apigee

    9. เพิ่มไฟล์ใบอนุญาตที่มีไฟล์ใบอนุญาต Apigee Edge สำหรับ Private Cloud ที่ถูกต้อง ชื่อไฟล์ต้องเป็น license.txt
    10. คัดลอกเนื้อหาของไฟล์ ~/.apigee-secure/license.txt ไปยังไฟล์ license.txt ที่คุณเพิ่งสร้าง
    11. กำหนดค่าต่อไปนี้ในไฟล์ ~/.apigee/custom-properties.yml
      • opdk_version: 'OPDK_VERSION'
      • apigee_repo_url: 'APIGEE_REPO_URL'

      สถานที่:

      • OPDK_VERSION คือเวอร์ชัน Apigee Edge สำหรับ Private Cloud ที่คุณต้องการติดตั้ง
      • APIGEE_REPO_URL คือ URL ของที่เก็บ Apigee

    12. ส่งออกไฟล์การกำหนดค่าเป็นตัวแปรสภาพแวดล้อม 
      export ANSIBLE_CONFIG=~/.ansible/multi-planet-configurations/prod.cfg

    ติดตั้งคอมโพเนนต์ Apigee

    ในขั้นตอนนี้ ผู้ปฏิบัติงาน GDC จะติดตั้งคอมโพเนนต์ Apigee โดยใช้ Ansible

    วิธีติดตั้งคอมโพเนนต์ Apigee

    1. แทนที่ที่เก็บ Git ระยะไกลด้วยไฟล์ในเครื่อง 
      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. ติดตั้งข้อกำหนดของ Ansible 
      ansible-galaxy install -r requirements.yml -f
    3. แก้ไขข้อบกพร่องของบทบาท 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. แทนที่เนื้อหาของไฟล์ install.yml ด้วยเนื้อหาใน apigee/scripts/ansible/install.yml
    5. เรียกใช้ Playbook เพื่อติดตั้งคอมโพเนนต์ Apigee โดยทำดังนี้ 
      ansible-playbook install.yml
    6. ปิดใช้ลิงก์รีเซ็ตรหัสผ่านของผู้ใช้ใน Edge UI Apigee ใน GDC ที่แยกจากอินเทอร์เน็ตไม่มี เซิร์ฟเวอร์ SMTP ทำตามขั้นตอนในปิดใช้ลิงก์รีเซ็ตรหัสผ่านใน UI ของ Edge

    ติดตั้งใช้งานพ็อดและบริการ

    ในขั้นตอนนี้ คุณจะนำพ็อดและบริการของโปรแกรมอัปโหลด พร็อกซีแบบย้อนกลับ ตัวจัดสรรภาระงาน และการบันทึกไปใช้งาน

    วิธีติดตั้งใช้งานพ็อดและบริการ

    1. ทำตามวิธีการใน สร้างอินสแตนซ์รีจิสทรี Harbor เพื่อสร้างอินสแตนซ์ Harbor ในโปรเจ็กต์ GDC dev-apigee
    2. ทําตามวิธีการใน สร้างโปรเจ็กต์ Harbor เพื่อสร้างโปรเจ็กต์ Harbor ชื่อ apigee
    3. ทำตามวิธีการในกำหนดค่าการควบคุมการเข้าถึงเพื่อตั้งค่าการควบคุมการเข้าถึงสำหรับโปรเจ็กต์ Harbor
    4. ทําตามวิธีการในลงชื่อเข้าใช้ Docker และ Helm เพื่อ กําหนดค่าการตรวจสอบสิทธิ์ Docker
    5. อัปเดตที่อยู่ IP ในไฟล์ apigee/apigee_user_cluster.toml ตามที่แสดง 
      mgmt-server-proxy = "APIGEE_NODE1_EXTERNAL_IP"
router-proxy1 = "APIGEE_NODE2_EXTERNAL_IP"
router-proxy2 = "APIGEE_NODE3_EXTERNAL_IP"

      สถานที่:

      • APIGEE_NODE1_EXTERNAL_IP คือที่อยู่ IP ภายนอกของโหนด Apigee1 ที่ได้รับในขั้นตอนก่อนหน้า
      • APIGEE_NODE2_EXTERNAL_IP คือที่อยู่ IP ภายนอกของโหนด Apigee2 ที่ได้รับในขั้นตอนก่อนหน้า
      • APIGEE_NODE3_EXTERNAL_IP คือที่อยู่ IP ภายนอกของโหนด Apigee3 ที่ได้ในขั้นตอนก่อนหน้า

    6. วางไฟล์ใบรับรอง SSL (server.crt) และไฟล์คีย์ (server.key) สำหรับการกำหนดค่า HTTPS ไว้ในโฟลเดอร์ apigee/mgmt-server-proxy และ apigee/router-proxy

      หากต้องการสร้างใบรับรองที่ลงนามด้วยตนเอง ให้ใช้คำสั่งต่อไปนี้ 

      openssl req -newkey rsa:4096 -x509 -nodes -keyout server.key -new -out server.crt -subj "/CN=*.apigeetest.com" -sha256 -days 365
    7. อัปเดตค่าของ SSH-PASSWORD สำหรับผู้ใช้รากในคอนเทนเนอร์โปรแกรมอัปโหลดในไฟล์ apigee/uploader/Dockerfile 
      RUN echo 'root:SSH_PASSWORD' | chpasswd
    8. รับข้อมูลเข้าสู่ระบบสำหรับคลัสเตอร์ผู้ใช้โดยใช้คำสั่งต่อไปนี้ 
      gdcloud clusters get-credentials USER_CLUSTER

      โดยที่ USER_CLUSTER คือชื่อของคลัสเตอร์ GKE ของผู้ใช้

    9. เรียกใช้สคริปต์การทำให้ใช้งานได้เพื่อทำให้พ็อดและบริการใช้งานได้ 
      source venv/bin/activate
python apigee/solution_deploy_user_cluster.py gdc-air-gapped
    10. รับที่อยู่ IP ภายนอกของบริการ 
      kubectl get svc -n $PROJECT_ID

    อัปเดต IP ของโปรแกรมอัปโหลดและตัวส่งต่อ Fluent Bit

    ในขั้นตอนนี้ คุณจะอัปเดต IP ของโปรแกรมอัปโหลดและตัวส่งต่อ Fluent Bit ในสคริปต์การตั้งค่าการสำรองข้อมูลและ Apigee

    1. อัปเดต SSH_PASSWORD, root และ UPLOADER_EXTERNAL_IP ใน 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/

      สถานที่:

      • SSH_PASSWORD คือรหัสผ่านสำหรับผู้ใช้ราก
      • UPLOADER_EXTERNAL_IP คือที่อยู่ IP ภายนอกของบริการอัปโหลดที่ได้รับในขั้นตอนก่อนหน้า

    2. อัปเดต FLUENTBIT_EXTERNAL_IP ใน apigee/helm/scripts/apigee_setup.sh ดังนี้ 
      export FLUENTBIT_EXTERNAL_IP=FLUENTBIT_EXTERNAL_IP

    การอัปเดตสคริปต์เริ่มต้นต้องรีสตาร์ทโหนด Apigee วิธีรีสตาร์ทโหนด

    1. หยุด 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. ติดตั้งแผนภูมิ Helm อีกครั้ง 
      python apigee/solution_deploy.py gdc-air-gapped
    3. เริ่ม VM โดยทำดังนี้ 
      for i in 1 2 3 4 5; do
  GDCloud compute instances start node$i --project $PROJECT
  done

    เริ่มใช้งานองค์กร Apigee

    ในขั้นตอนนี้ ผู้ปฏิบัติงาน GDC จะเริ่มต้นใช้งานองค์กร Apigee โดยการเรียกใช้สคริปต์การตั้งค่าใน node1

    วิธีเริ่มต้นใช้งานองค์กร Apigee

    1. อัปเดตค่าต่อไปนี้ใน apigee/scripts/apigee_org_setup.sh ตามที่แสดง อัปเดต พารามิเตอร์อื่นๆ ตามต้องการ 
      IP1=APIGEE_NODE1_INTERNAL_IP

VHOST_ALIAS="APIGEE_NODE2_EXTERNAL_IP:9001 APIGEE_NODE3_EXTERNAL_IP:9001"

      สถานที่:

      • APIGEE_NODE1_INTERNAL_IP คือที่อยู่ IP ภายในของโหนด Apigee1 ที่ได้รับในขั้นตอนก่อนหน้า
      • APIGEE_NODE2_EXTERNAL_IP คือที่อยู่ IP ภายนอกของโหนด Apigee2 ที่ได้รับในขั้นตอนก่อนหน้า
      • APIGEE_NODE3_EXTERNAL_IP คือที่อยู่ IP ภายนอกของโหนด Apigee3 ที่ได้รับในขั้นตอนก่อนหน้า

    2. เรียกใช้สคริปต์ใน node1 เพื่อเริ่มต้นใช้งานองค์กร 
      chmod a+x apigee_org_setup.sh
./apigee_org_setup.sh

    ทดสอบการเชื่อมต่อ HTTP

    ในขั้นตอนนี้ คุณจะทดสอบการเชื่อมต่อ HTTP สำหรับ Management API และพร็อกซี API

    วิธีทดสอบการเชื่อมต่อ HTTP

    1. รับที่อยู่ IP ภายนอกของบริการ apigee-elb 
      gdcloud clusters get-credentials USER_CLUSTER
export PROJECT=dev-apigee
kubectl get svc apigee-elb -n $PROJECT

      โดยที่ USER_CLUSTER คือชื่อของคลัสเตอร์ GKE ของผู้ใช้

      บริการนี้ทำหน้าที่เป็นปลายทางสำหรับ UI ของ Edge, Management API และพร็อกซี API

    ทดสอบ Management API

    หากต้องการทดสอบ Management API ให้ส่งคำขอ HTTP ไปยังปลายทางต่อไปนี้ 

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

    สถานที่:

    • APIGEE_ELB_EXTERNAL_IP คือที่อยู่ IP ภายนอกของบริการ apigee-elb ที่ได้รับในขั้นตอนก่อนหน้า
    • ORG_NAME คือชื่อองค์กร Apigee
    • ENV_NAME คือชื่อของสภาพแวดล้อม Apigee

    ทดสอบพร็อกซี API

    วิธีทดสอบพร็อกซี API

    1. เข้าสู่ระบบ Edge UI
    2. ในหน้าพร็อกซี API ให้คลิกสร้างเพื่อสร้างพร็อกซี API ใหม่
    3. ในหน้ารายละเอียดพร็อกซี ให้ป้อนค่าต่อไปนี้
      • ประเภทพร็อกซี: เลือกไม่มีเป้าหมาย
      • ชื่อพร็อกซี: ok
      • เส้นทางฐาน: /ok
      • เป้าหมาย: http://APIGEE_ELB_EXTERNAL_IP:9001
    4. คลิกสร้างเพื่อสร้างพร็อกซี API
    5. ส่งคำขอ HTTP ไปยัง /ok ดังนี้ 
      curl -i http://APIGEE_ELB_EXTERNAL_IP:9001/ok
    6. ยืนยันว่าคำตอบคือ 200 OK

    กำหนดค่า TLS และทดสอบ HTTPS

    ในขั้นตอนนี้ ผู้ปฏิบัติงาน GDC จะกำหนดค่า Transport Layer Security (TLS) สำหรับพร็อกซี API, Edge UI และ Management API

    กำหนดค่า TLS สำหรับพร็อกซี API

    1. ทำตามขั้นตอนในสร้างที่เก็บคีย์/ที่เก็บที่เชื่อถือได้และชื่อแทน เพื่อสร้างใบรับรองแบบ Self-signed โดยใช้ค่าต่อไปนี้
      • KeyStore: myTestKeystore
      • KeyAlias: myKeyAlias
      • ชื่อทั่วไป: apigeetest.com
    2. เรียก API เพื่อสร้างโฮสต์เสมือนชื่อ 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>'

      สถานที่:

      • APIGEE_ELB_EXTERNAL_IP คือที่อยู่ IP ภายนอกของบริการ apigee-elb ที่ได้รับในขั้นตอนก่อนหน้า
      • ORG_NAME คือชื่อองค์กร Apigee
      • ENV_NAME คือชื่อของสภาพแวดล้อม Apigee ที่ควรสร้างโฮสต์เสมือน
    3. สร้างพร็อกซี API โดยใช้โฮสต์เสมือนที่ปลอดภัย
    4. กำหนดค่าการแปลง DNS สำหรับโฮสต์เสมือนในเราเตอร์ 
      echo '127.0.0.1 api.apigeetest.com' | sudo tee -a /etc/hosts
    5. ยืนยันว่าโฮสต์เสมือนทำงานในเครื่องโดยส่งคำขอ HTTPS ไปยังปลายทางต่อไปนี้ 
      curl https://api.apigeetest.com:9005/ok -v -k
    6. กำหนดค่าการแปลง DNS สำหรับอุปกรณ์ปลายทาง 
      echo 'APIGEE_ELB_EXTERNAL_IP apigeetest.com' | sudo tee -a /etc/hosts

      โดย APIGEE_ELB_EXTERNAL_IP คือที่อยู่ IP ภายนอกของบริการ apigee-elb ที่ได้รับในขั้นตอนก่อนหน้า

    7. ไปที่ https://apigeetest.com/ok ในเว็บเบราว์เซอร์และยืนยันว่าใช้งานได้

    กำหนดค่า TLS สำหรับ Edge UI

    วิธีกำหนดค่า TLS สำหรับ Edge UI

    1. สร้างไฟล์คีย์สโตร์จากไฟล์ใบรับรอง SSL และไฟล์คีย์ 
      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. วางไฟล์ Keystore ไว้ในโฟลเดอร์ Apigee ใน node1 
      scp -i SSH_PRIVATE_KEY_FILE keystore.jks admin@APIGEE_NODE1_EXTERNAL_IP:/home/admin/

      สถานที่:

      • SSH_PRIVATE_KEY_FILE คือชื่อไฟล์ที่มีคีย์ส่วนตัว SSH ของโหนด Apigee
      • APIGEE_NODE1_EXTERNAL_IP คือที่อยู่ IP ภายนอกของโหนด Apigee1 ที่ได้รับในขั้นตอนก่อนหน้า

    3. SSH ไปยัง node1 แล้วย้ายไฟล์ที่เก็บคีย์ไปยังโฟลเดอร์ Apigee โดยทำดังนี้ 
      sudo mv keystore.jks /opt/apigee/customer/application/
    4. สร้างไฟล์การกำหนดค่า SSL 
      sudo vi /tmp/sslConfigFile
    5. อัปเดตค่าของ KEY-PASS-PHRASE ดังที่แสดง 
      HTTPSPORT=9443
DISABLE_HTTP=n
KEY_ALGO=JKS
KEY_FILE_PATH=/opt/apigee/customer/application/keystore.jks
KEY_PASS=KEY_PASS_PHRASE
    6. กำหนดค่า SSL โดยใช้ไฟล์การกำหนดค่า 
      sudo chown apigee:apigee /tmp/sslConfigFile
/opt/apigee/apigee-service/bin/apigee-service edge-ui configure-ssl -f /tmp/sslConfigFile
    7. กำหนดค่าการแปลง DNS สำหรับ Edge UI โดยทำดังนี้ 
      echo 'APIGEE_ELB_EXTERNAL_IP ui.apigeetest.com' | sudo tee -a /etc/hosts

      โดย APIGEE_ELB_EXTERNAL_IP คือที่อยู่ IP ภายนอกของบริการ apigee-elb ที่ได้รับในขั้นตอนก่อนหน้า

    8. เข้าถึง https://ui.apigeetest.com:9443 ในเว็บเบราว์เซอร์และยืนยันว่าใช้งานได้ ดูรายละเอียดเพิ่มเติมได้ที่คู่มือ

    กำหนดค่า TLS สำหรับ Management API

    วิธีกำหนดค่า TLS สำหรับ Management API

    1. กำหนดค่าเจ้าของไฟล์คีย์สโตร์ (ใช้ไฟล์เดียวกับ UI ของ Edge): 
      sudo chown apigee:apigee /opt/apigee/customer/application/keystore.jks
    2. สร้างไฟล์พร็อพเพอร์ตี้ 
      sudo vi /opt/apigee/customer/application/management-server.properties

      3. แทนที่ค่าของ KEY_PASS_PHRASE ด้วยรหัสผ่านของที่เก็บคีย์ ดังที่แสดง 

      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. รีสตาร์ทเซิร์ฟเวอร์การจัดการเพื่อให้การเปลี่ยนแปลงมีผล 
      /opt/apigee/apigee-service/bin/apigee-service edge-management-server restart
    4. ยืนยันว่า HTTPS ใช้งานได้ในเครื่อง 
      curl -u "opdk@apigee.com:Apigee123!" "https://localhost:8443/v1/users" -k
    5. จากไคลเอ็นต์ ให้เข้าถึง https://apigeetest.com:8443/v1/users ในเบราว์เซอร์ ป้อนชื่อผู้ใช้และรหัสผ่านของผู้ดูแลระบบเพื่อยืนยันว่าได้กำหนดค่าข้อมูลเข้าสู่ระบบอย่างถูกต้อง

    ขั้นตอนถัดไป