התקנת Apigee ב-Google Distributed Cloud במודל Air-gapped

במדריך הזה מוסבר איך להתקין ולפרוס את Apigee Edge לענן פרטי ואת פרוקסי API בסביבת Google Distributed Cloud ‏(GDC) עם בידוד פיזי. מוצרי GDC air-gapped, כולל Apigee Edge for Private Cloud, לא דורשים קישוריות ל-Google Cloud כדי לנהל את התשתית והשירותים. אתם יכולים להשתמש במישור בקרה מקומי שמתארח במקום כדי לבצע את כל הפעולות. סקירה כללית על GDC עם בידוד פיזי זמינה כאן.

המדריך הזה מיועד למפעילים של Apigee שמכירים את Apigee Edge לענן פרטי ויש להם הבנה בסיסית של Kubernetes.

סקירה כללית של השלבים הנדרשים

כדי להתקין ולפרוס את Apigee Edge for Private Cloud בסביבת GDC עם פער אוויר, המפעיל צריך לבצע את השלבים הבאים:

לפני שמתחילים

לפני שמתחילים בתהליך ההתקנה, חשוב לבצע את השלבים הבאים:

  1. אם אין לכם פרויקט GDC, צריך ליצור אחד כדי להשתמש בו להתקנה. מידע נוסף זמין במאמר יצירת פרויקט.
  2. מורידים, מתקינים ומגדירים את gdcloud CLI בתחנת עבודה שמחוברת ל-GDC או בסביבת הפריסה הרציפה של הארגון.
  3. מקבלים את פרטי הכניסה שנדרשים לשימוש ב-gdcloud CLI וב-kubectl API. במאמר אימות החשבון לצורך גישה מפורטים השלבים הנדרשים.
  4. מאשרים את שם המשתמש והסיסמה של Apigee שקיבלתם ממנהל החשבון שלכם ב-Apigee.
  5. מאשרים את השם של אשכול האדמין ב-GKE ואת השם של אשכול המשתמש ב-GKE.

דרישות הקיבולת

כדי להתקין את Apigee Edge for Private Cloud ב-GDC, צריך כמה מכונות וירטואליות (VM) עם הקצאות משאבים ספציפיות. המכונות הווירטואליות האלה מחויבות על סמך משאבי המחשוב שלהן (RAM, ליבות vCPU) ואחסון בדיסק מקומי. מידע נוסף מפורט במאמר בנושא תמחור.

בטבלה הבאה מפורטות דרישות המשאבים לכל מכונה וירטואלית:

סוג ה-VM RAM ליבות vCPU אחסון בדיסק
צומת מאגר 8GB ליבות עם 2 vCPU ‫64GB
צומת בקרה 8GB ליבות עם 2 vCPU ‫64GB
צמתים 1, 2 ו-3 של Apigee API Management ‫RAM בנפח 16GB 8 ליבות vCPU ‫670GB
צמתים לניהול API ב-Apigee‏ 4 ו-5 ‫RAM בנפח 16GB 8 ליבות vCPU ‫500GB עד 1TB

תפקידים והרשאות

כדי לפרוס את Apigee Edge for 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 עם פער אבטחה (air-gapped) זמין במאמר מתן וביטול גישה.

    מגבלות

    המגבלות הבאות חלות על Apigee ב-GDC air-gapped:

    • ‫Apigee on GDC air-gapped לא כולל שרתי DNS, ומשתמש בפענוח DNS מקומי כפתרון עקיף. אם Apigee on GDC air-gapped נפרס בסביבה עם שרתי DNS חיצוניים, צריך להחליף את השלבים להגדרת DNS מקומי בהגדרת רשומות DNS בשרתי ה-DNS.
    • ‫Apigee ב-GDC air-gapped לא כולל שרת SMTP עצמאי. אפשר להגדיר שרת SMTP בכל שלב כדי להפעיל התראות באימייל לגבי יצירת חשבון ואיפוס סיסמה משרת הניהול ומממשק המשתמש לניהול. ממשקי ה-API לניהול נשארים זמינים לניהול חשבונות משתמשים ב-Apigee. מידע נוסף זמין במאמר הגדרת שרת SMTP של Edge.
    • ב-Apigee ב-GDC עם פער אוויר לא מיושם זיהוי ומניעה של פריצות אבטחה. מתקינים ומגדירים מערכת למניעת פריצות (IPS), כמו Snort, כדי לזהות ולמנוע פעילויות זדוניות.

    קבלת הקבצים הנדרשים

    כדי לקבל את קובצי ההתקנה, צריך קודם להגדיר צומת מחובר ואז להוריד את הקבצים.

    הגדרת צומת מקושר

    הצומת המחובר הוא מכונה וירטואלית יחידה מחוץ ל-GDC שמשמשת להורדת קובצי ההתקנה. המכונה הווירטואלית הזו דורשת גישה לאינטרנט ומשמשת רק לתהליך ההתקנה.

    לצומת המחובר נדרשים הקיבולת וההגדרה הבאות:

    • מערכת הפעלה: Rocky Linux 8
    • גודל המכונה: זיכרון RAM בנפח 8GB;‏ 2 ליבות vCPU;‏ נפח אחסון של 64GB בדיסק מקומי
    • קישוריות:
      • ‫Ingress: TCP 22 (SSH)
      • יציאה: אינטרנט

    כדי ליצור את הצומת המחובר, פועלים לפי ההוראות במאמר יצירה והפעלה של מכונת VM. אחרי שיוצרים את ה-VM, פועלים לפי ההוראות במאמר התחברות למכונות VM של Linux. כדי להתחבר ל-VM. רשימת מערכות ההפעלה הנתמכות מופיעה במאמר מערכות הפעלה נתמכות ב-GDC.

    הורדת קובצי התקנה

    כדי להוריד את קובצי ההתקנה:

    1. כדאי לעיין בנתוני הגרסה של Apigee Edge for Private Cloud כדי לראות את הגרסה הרשמית העדכנית ביותר שנתמכת ב-GDC, כפי שמצוין בעמודה Edge for 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 for Private Cloud לשימוש ב-GDC שאתם מתכוונים להתקין, לדוגמה, 4.53.01.
    3. מורידים את קובץ bootstrap_VERSION.sh האחרון של Apigee Edge for Private Cloud אל /tmp/bootstrap_VERSION.sh: 
      curl https://software.apigee.com/bootstrap_VERSION.sh -o /tmp/bootstrap_VERSION.sh

      ‫VERSION היא הגרסה העדכנית של Apigee Edge for Private Cloud לשימוש ב-GDC שאתם מתכוונים להתקין, לדוגמה, 4.53.01.

    4. מתקינים את כלי השירות Edge apigee-service ואת יחסי התלות שלו: 
      sudo bash /tmp/bootstrap_VERSION.sh apigeeuser=APIGEE_USER apigeepassword=APIGEE_PASSWORD

      כאשר:

      • ‫APIGEE_USER הוא שם המשתמש שקיבלתם לארגון ב-Apigee.
      • ‫APIGEE_PASSWORD היא הסיסמה שקיבלתם לארגון Apigee.
      • ‫VERSION היא גרסת Apigee Edge for 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 for 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 הוא שם הקטגוריה שרוצים ליצור לאחסון קובצי הגיבוי של Apigee Edge for 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

      ההגדרה הזו יוצרת קטגוריה עם תקופת שמירה של 30 יום.

    הגדרת גישה לקטגוריה

    כדי להגדיר גישה לקטגוריית האחסון:

    1. יוצרים חשבון שירות בפרויקט: 
      gdcloud iam service-accounts create $BUCKET-sa \
    --project=$PROJECT
    2. יוצרים את התפקיד ואת קישור התפקיד כדי ליצור סוד לגישה לקטגוריה: 
      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. יוצרים סוד לשימוש מעלה הקבצים באשכול 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 for 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 for Private Cloud שרוצים להתקין.

    פריסת צמתים של Apigee

    בשלב הזה, האופרטור של GDC פורס את הצמתים של Apigee API Management.

    יצירת צמתים של Apigee

    כדי ליצור את הצמתים של Apigee API Management:

    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 Management:

    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
        • שליפת מאגרי תצורה באמצעות Git HTTPS
      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 היא הסיסמה של שרת הניהול של Apigee QPID.

    9. מוסיפים קובץ רישיון עם קובץ רישיון תקין של Apigee Edge לענן פרטי. שם הקובץ חייב להיות 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 לענן פרטי שרוצים להתקין.
      • ‫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. ‫Apigee ב-GDC עם פער אוויר לא כולל שרת SMTP. פועלים לפי השלבים במאמר השבתת הקישור לאיפוס הסיסמה ב ממשק המשתמש של Edge.

    פריסת פודים ושירותים

    בשלב הזה פורסים את מעלה הקבצים, את ה-reverse proxy, את מאזן העומסים ואת שירותי ה-pods והרישום.

    כדי לפרוס את ה-pods והשירותים:

    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 החיצונית של הצומת node1 של Apigee, שקיבלתם בשלב קודם.
      • ‫APIGEE_NODE2_EXTERNAL_IP היא כתובת ה-IP החיצונית של הצומת Apigee node2 שהתקבלה בשלב קודם.
      • ‫APIGEE_NODE3_EXTERNAL_IP היא כתובת ה-IP החיצונית של הצומת Apigee node3 שהתקבלה בשלב מוקדם יותר.

    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 עבור משתמש ה-root במאגר ההעלאה בקובץ apigee/uploader/Dockerfile: 
      RUN echo 'root:SSH_PASSWORD' | chpasswd
    8. מקבלים את פרטי הכניסה לאשכול המשתמשים: 
      gdcloud clusters get-credentials USER_CLUSTER

      כאשר USER_CLUSTER הוא שם אשכול GKE של המשתמש.

    9. מריצים את סקריפט הפריסה כדי לפרוס את קבוצות ה-Pod והשירותים: 
      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 forwarder

    בשלב הזה, מעדכנים את כתובות ה-IP של מעלה הנתונים ושל Fluent Bit forwarder בסקריפטים של הגיבוי וההגדרה של 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. מפסיקים את המכונות הווירטואליות: 
      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. מפעילים את המכונות הווירטואליות: 
      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 הפנימית של צומת Apigee‏ node1 שקיבלתם בשלב קודם.
      • ‫APIGEE_NODE2_EXTERNAL_IP היא כתובת ה-IP החיצונית של הצומת Apigee node2 שהתקבלה בשלב קודם.
      • ‫APIGEE_NODE3_EXTERNAL_IP היא כתובת ה-IP החיצונית של הצומת Apigee node3 שהתקבלה בשלב מוקדם יותר.

    2. מריצים את הסקריפט ב-node1 כדי לצרף את הארגון: 
      chmod a+x apigee_org_setup.sh
./apigee_org_setup.sh

    בדיקת קישוריות HTTP

    בשלב הזה בודקים את קישוריות ה-HTTP ל-Management API ול-API proxy.

    כדי לבדוק את הקישוריות של 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 של המשתמש.

      השירות הזה משמש כנקודת הקצה של ממשק המשתמש של Edge, של Management API ושל API Proxy.

    בדיקת 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 proxy

    כדי לבדוק את שרת ה-API הפרוקסי:

    1. מתחברים אל ממשק המשתמש של Edge.
    2. בדף API Proxies, לוחצים על Create כדי ליצור שרת proxy חדש ל-API.
    3. בדף פרטי השרת הפרוקסי, מזינים את הערכים הבאים:
      • סוג שרת proxy: בוחרים באפשרות ללא יעד.
      • שם שרת ה-Proxy: ok
      • נתיב בסיס: /ok
      • יעד: http://APIGEE_ELB_EXTERNAL_IP:9001
    4. לוחצים על Create (יצירה) כדי ליצור את ה-API proxy.
    5. שליחת בקשת HTTP אל /ok: 
      curl -i http://APIGEE_ELB_EXTERNAL_IP:9001/ok
    6. מאשרים שהתשובה היא 200 OK.

    הגדרת TLS ובדיקת HTTPS

    בשלב הזה, האופרטור של GDC מגדיר Transport Layer Security ‏ (TLS) ל-API proxy, לממשק המשתמש של Edge ול-Management API.

    הגדרת TLS לשרת ה-proxy של ה-API

    1. פועלים לפי השלבים במאמר יצירה של מאגר מפתחות/מאגר אישורים וכינוי כדי ליצור אישור בחתימה עצמית עם הערכים הבאים:
      • ‫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

    כדי להגדיר TLS בממשק המשתמש של Edge:

    1. יוצרים קובץ keystore מקובץ אישור ה-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. ממקמים את קובץ מאגר המפתחות בתיקייה 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 החיצונית של הצומת node1 של Apigee, שקיבלתם בשלב קודם.

    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: 
      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. מגדירים את הבעלים של קובץ מאגר המפתחות (משתמשים באותו בעלים כמו בממשק המשתמש של 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 בדפדפן. מזינים את שם המשתמש והסיסמה של האדמין כדי לוודא שפרטי הכניסה מוגדרים בצורה נכונה.

    המאמרים הבאים