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

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

המדריך הזה מיועד למשתמשי 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 מעבדים וירטואליים 64GB
צומת בקרה 8GB ליבות עם 2 מעבדים וירטואליים 64GB
צמתים 1, 2 ו-3 של Apigee API Management ‫RAM בנפח 16GB 8 ליבות vCPU ‫670GB
צמתים 4 ו-5 של Apigee API management ‫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 gap זמין במאמר מתן וביטול גישה.

    מגבלות

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

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

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

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

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

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

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

    • מערכת הפעלה: Rocky Linux 8
    • גודל המכונה: זיכרון RAM בנפח 8GB; ליבות 2-vCPU; אחסון בדיסק מקומי בנפח 64GB
    • קישוריות:
      • תעבורה נכנסת: 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. מורידים את הקובץ האחרון של Apigee Edge for 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 לענן פרטי לשימוש ב-GDC שאתם מתכוונים להתקין, לדוגמה, 4.53.01.

    4. מתקינים את כלי השירות apigee-service של Edge ואת יחסי התלות שלו: 
      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. מגדירים את משתני הסביבה של הפרויקט ושל ה-bucket: 
      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
        • שליפה (checkout) של מאגרי תצורה באמצעות 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 עם air gap לא כולל שרת SMTP. פועלים לפי השלבים שבקטע השבתת הקישור לאיפוס הסיסמה ב ממשק המשתמש של Edge.

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

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

    כדי לפרוס את ה-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 החיצונית של צומת 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 עבור משתמש 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 היא הסיסמה של משתמש Root.
      • ‫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 מפעיל סקריפט הגדרה ב-node1 כדי להוסיף את הארגון Apigee.

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

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

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

    בשלב הזה, תבדקו את קישוריות ה-HTTP ל-Management API ול-proxy ל-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 של המשתמש.

      השירות הזה משמש כנקודת הקצה של ממשק המשתמש של Edge, של Management API ושל proxy ל-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.

    בדיקת ה-proxy ל-API

    כדי לבדוק את proxy ל-API:

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

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

    בשלב הזה, האופרטור GDC מגדיר Transport Layer Security ‏ (TLS) ל-proxy ל-API, לממשק המשתמש של 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. יוצרים proxy ל-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 בדפדפן. מזינים את שם המשתמש והסיסמה של האדמין כדי לוודא שפרטי הכניסה מוגדרים בצורה נכונה.

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