שידור הודעות HL7v2 דרך חיבורי TCP/IP

במדריך הזה מוסבר איך להעביר הודעות HL7v2 דרך חיבורי TCP/IP באמצעות פרוטוקול השכבה התחתונה המינימלי (MLLP). כדי לדרוש שהתמונה של MLLP תיחתם על ידי גורם מאמת (attestor), פועלים לפי השלבים במאמר בנושא העברת הודעות HL7v2 בחיבורי TCP/IP באמצעות תמונה חתומה של MLLP.

במדריך הזה מוסבר איך להריץ את מתאם MLLP בקוד פתוח שמתארח ב-GitHub בסביבות הבאות:

מטרות

בסיום המדריך הזה, תדעו איך:

עלויות

במסמך הזה משתמשים ברכיבים הבאים של Google Cloud, והשימוש בהם כרוך בתשלום:

  • Cloud Healthcare API
  • Google Kubernetes Engine
  • Compute Engine
  • Cloud VPN
  • Pub/Sub

כדי להעריך את ההוצאות בהתאם לתחזית השימוש שלכם, אתם יכולים להיעזר במחשבון העלויות.

משתמשים חדשים של Google Cloud ? יכול להיות שאתם זכאים לתקופת ניסיון בחינם.

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

לפני שמתחילים את המדריך הזה, כדאי לעיין במסמכי ההסבר על פרוטוקול מינימלי של שכבה תחתונה (MLLP) במאמר MLLP ומתאם MLLP Google Cloud . במסמכי הקונספט מוסבר על MLLP, על האופן שבו מערכות לטיפול יכולות לשלוח ולקבל הודעות אל Cloud Healthcare API וממנו דרך חיבור MLLP, ועל היסודות של אבטחת MLLP.

כדי להגדיר את מתאם MLLP, צריך לבחור או ליצורGoogle Cloud פרויקט ולהפעיל את ממשקי ה-API הנדרשים. לשם כך, מבצעים את השלבים הבאים:

  1. נכנסים לחשבון Google Cloud . אם אתם משתמשים חדשים ב- Google Cloud, צרו חשבון כדי שתוכלו להעריך את הביצועים של המוצרים שלנו בתרחישים מהעולם האמיתי. לקוחות חדשים מקבלים בחינם גם קרדיט בשווי 300$ להרצה, לבדיקה ולפריסה של עומסי העבודה.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Cloud Healthcare API, Google Kubernetes Engine, Container Registry, and Pub/Sub APIs, if any are not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the APIs

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Cloud Healthcare API, Google Kubernetes Engine, Container Registry, and Pub/Sub APIs, if any are not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the APIs

    8.
  8. מחכים עד שממשק ה-API של Kubernetes Engine והשירותים הקשורים מופעלים. הפעולה הזו יכולה להימשך כמה דקות.

בחירת מעטפת

כדי להשלים את המדריך הזה, אפשר להשתמש ב-Cloud Shell או במעטפת המקומית.

‫Cloud Shell היא סביבת Shell לניהול משאבים שמתארחים ב- Google Cloud. ב-Cloud Shell מותקנים מראש ה-CLI של gcloud וkubectl. ‫ה-CLI של gcloud הוא ממשק שורת הפקודה העיקרי ל- Google Cloud. ‫kubectl מספק את ממשק שורת הפקודה להרצת פקודות באשכולות GKE.

אם אתם מעדיפים להשתמש במעטפת המקומית, אתם צריכים להתקין את ה-CLI של gcloud.

כדי לפתוח את Cloud Shell או להגדיר את המעטפת המקומית:

Cloud Shell

כדי להפעיל את Cloud Shell, מבצעים את השלבים הבאים:

  1. עוברים אל Google Cloud המסוף.

    ‫Google Cloud console

  2. בפינה השמאלית העליונה של המסוף, לוחצים על הלחצן Activate Google Cloud Shell (הפעלת Google Cloud Shell):

בחלק התחתון של המסוף ייפתח סשן של Cloud Shell בתוך מסגרת. משתמשים במעטפת הזו כדי להריץ פקודות של gcloud ושל kubectl.

מעטפת מקומית

כדי להתקין את ה-CLI של gcloud ואת הכלי kubectl, מבצעים את השלבים הבאים:

  1. מתקינים ומפעילים את Google Cloud CLI.

  2. אם אתם משתמשים במעטפת מקומית, אתם צריכים ליצור פרטי כניסה לאימות מקומי עבור חשבון המשתמש: 

    gcloud auth application-default login

    אם אתם משתמשים ב-Cloud Shell, אין צורך לבצע את הפעולה הזו.

    אם מוחזרת שגיאת אימות ואתם משתמשים בספק זהויות חיצוני (IdP), ודאו ש נכנסתם ל-CLI של gcloud באמצעות המאגר המאוחד לניהול זהויות.

  3. אם אתם רק בודקים את המתאם באופן מקומי, אתם לא צריכים לבצע עוד שלבים ויכולים להמשיך אל יצירת מערך נתונים. אם פורסים את המתאם ב-GKE, מריצים את הפקודה הבאה כדי להתקין את כלי שורת הפקודה kubectl:

    gcloud components install kubectl

יצירת מערך נתונים

אם עדיין לא יצרתם מערך נתונים של Cloud Healthcare API, אתם צריכים ליצור מערך נתונים באופן הבא:

המסוף

  1. נכנסים לדף Datasets במסוף Google Cloud .

    למעבר אל Datasets

  2. לוחצים על יצירת מערך נתונים.
  3. בשדה שם, מזינים מזהה לקבוצת הנתונים. מזהה מערך הנתונים צריך לכלול את הפרטים הבאים:
    • מזהה ייחודי במיקום שלו
    • מחרוזת Unicode באורך 1-256 תווים, שמורכבת מהתווים הבאים:
      • Numbers
      • מכתבים
      • קו תחתון
      • מקפים
      • פרקי הזמן
  4. בקטע סוג המיקום, בוחרים אחד מסוגי המיקומים הבאים:
    • אזור: מערך הנתונים נמצא באופן קבוע באזור אחד Google Cloud . אחרי הבחירה, מקלידים או בוחרים את המיקום בשדה אזור.
    • מספר אזורים: מערך הנתונים נמצא באופן קבוע במיקום אחד שכולל מספר Google Cloud אזורים. אחרי הבחירה, מקלידים או בוחרים את המיקום במספר אזורים בשדה Multi-region.
  5. לוחצים על יצירה.

מערך הנתונים החדש מופיע ברשימת מערכי הנתונים.

gcloud

כדי ליצור מערך נתונים, מריצים את הפקודה gcloud healthcare datasets create:

gcloud healthcare datasets create DATASET_ID \
    --location=LOCATION

אם הבקשה מבוצעת בהצלחה, הפקודה תחזיר את הפלט הבא:

Create request issued for: [DATASET_ID]
Waiting for operation [OPERATION_ID] to complete...done.
Created dataset [DATASET_ID].

יצירת נושא ומינוי ב-Pub/Sub

כדי לקבל התראות כשנוצרות הודעות או כשהן נבלעות, צריך להגדיר נושא Pub/Sub בחנות HL7v2. מידע נוסף על הגדרת התראות ב-Pub/Sub

כדי ליצור נושא:

המסוף

  1. נכנסים לדף Topics של Pub/Sub במסוף Google Cloud .

    מעבר לדף הנושאים של Pub/Sub

  2. לוחצים על יצירת נושא.

  3. מזינים שם לנושא עם ה-URI:

    projects/PROJECT_ID/topics/TOPIC_NAME

    כאשר PROJECT_ID הוא מזהה הפרויקט. Google Cloud

  4. לוחצים על יצירה.

gcloud

כדי ליצור נושא, מריצים את הפקודה gcloud pubsub topics create:

gcloud pubsub topics create projects/PROJECT_ID/topics/TOPIC_NAME

אם הבקשה מבוצעת בהצלחה, הפקודה תחזיר את הפלט הבא:

Created topic [projects/PROJECT_ID/topics/TOPIC_NAME].

כדי ליצור מינוי, מבצעים את השלבים הבאים:

המסוף

  1. נכנסים לדף Topics של Pub/Sub במסוף Google Cloud .

    מעבר לדף הנושאים של Pub/Sub

  2. לוחצים על הנושא של הפרויקט.

  3. לוחצים על יצירת מינוי.

  4. מזינים שם מינוי:

    projects/PROJECT_ID/subscriptions/SUBSCRIPTION_NAME

  5. משאירים את האפשרות סוג ההעברה כפי שהיא (משיכה) ולוחצים על יצירה.

gcloud

כדי ליצור מינוי, מריצים את הפקודה gcloud pubsub subscriptions create:

gcloud pubsub subscriptions create SUBSCRIPTION_NAME \
    --topic=projects/PROJECT_ID/topics/TOPIC_NAME

אם הבקשה מבוצעת בהצלחה, הפקודה תחזיר את הפלט הבא:

Created subscription [projects/PROJECT_ID/subscriptions/SUBSCRIPTION_NAME].

יצירת חנות HL7v2 שמוגדר בה נושא Pub/Sub

יוצרים חנות HL7v2 ומגדירים אותה עם נושא Pub/Sub. כדי ליצור חנות HL7v2, צריך קודם ליצור מערך נתונים. לצורך המדריך הזה, צריך להשתמש באותו פרויקט בשביל מאגר HL7v2 ובשביל הנושא ב-Pub/Sub.

כדי ליצור מאגר HL7v2 שמוגדר עם נושא Pub/Sub, מבצעים את השלבים הבאים:

curl

curl -X POST \
    --data "{
      'notificationConfigs': [
        {
          'pubsubTopic': 'projects/PROJECT_ID/topics/PUBSUB_TOPIC',
          'filter': ''
        }
      ]
    }" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores?hl7V2StoreId=HL7V2_STORE_ID"

אם הבקשה מצליחה, השרת מחזיר את התגובה בפורמט JSON:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID",
  "notificationConfigs": [
    {
      "pubsubTopic": "projects/PROJECT_ID/topics/PUBSUB_TOPIC"
    }
  ]
}

PowerShell

$cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Post `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -Body "{
      'notificationConfigs': [
        {
          'pubsubTopic': 'projects/PROJECT_ID/topics/PUBSUB_TOPIC',
          'filter': ''
        }
      ]
  }" `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores?hl7V2StoreId=HL7V2_STORE_ID" | Select-Object -Expand Content

אם הבקשה מצליחה, השרת מחזיר את התגובה בפורמט JSON:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID",
  "notificationConfigs": [
    {
      "pubsubTopic": "projects/PROJECT_ID/topics/PUBSUB_TOPIC"
    }
  ]
}

הגדרת הרשאות Pub/Sub

כדי לשלוח התראות ל-Pub/Sub כשנוצרת הודעת HL7v2 או כשהיא מוזנת, צריך להגדיר הרשאות Pub/Sub ב-Cloud Healthcare API. צריך לבצע את השלב הזה פעם אחת לכל פרויקט.

כדי להוסיף את התפקיד הנדרש pubsub.publisher לחשבון השירות של הפרויקט:

המסוף

  1. בדף IAM במסוף Google Cloud , מוודאים שהתפקיד Healthcare Service Agent מופיע בעמודה Role של חשבון השירות הרלוונטי בפרויקט. שם החשבון הוא service-PROJECT_NUMBER@gcp-sa-healthcare.iam.gserviceaccount.com. מידע על איתור PROJECT_NUMBER זמין במאמר זיהוי פרויקטים.

  2. בעמודה ירושה שמתאימה לתפקיד, לוחצים על סמל העיפרון. נפתחת החלונית עריכת הרשאות.

  3. לוחצים על Add another role ומחפשים את התפקיד Pub/Sub Publisher.

  4. בוחרים את התפקיד ולוחצים על שמירה. התפקיד pubsub.publisher נוסף לחשבון השירות.

gcloud

כדי להוסיף את ההרשאות לחשבון השירות, מריצים את הפקודה gcloud projects add-iam-policy-binding. מידע על איתור PROJECT_ID וPROJECT_NUMBER זמין במאמר זיהוי פרויקטים.

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-healthcare.iam.gserviceaccount.com \
    --role=roles/pubsub.publisher

שליפת קובץ האימג' של Docker שנבנה מראש

מתאם MLLP הוא אפליקציה מבוססת-קונטיינר שמוצבת בקובץ אימג' של Docker שנבנה מראש ב-Container Registry.

כדי למשוך את הגרסה העדכנית של האימג', מריצים את הפקודה הבאה:

docker pull gcr.io/cloud-healthcare-containers/mllp-adapter:latest

בדיקת המתאם של MLLP באופן מקומי

כשבודקים את המתאם באופן מקומי, אפשר להגדיר אותו לפעול כמקלט, כמפרסם או כשניהם. ההבדלים העיקריים בין ההגדרות של המקבל לבין ההגדרות של בעל האתר:

  • כשהמתאם פועל כמקלט, הוא מקבל הודעות של HL7v2 ממקור חיצוני ומפעיל את messages.ingest כדי להטמיע את ההודעות במאגר HL7v2, וכך ליצור התראה של Pub/Sub. ההתראה נשלחת לאפליקציות שרשומות לנושא Pub/Sub של מאגר HL7v2.
  • כשהמתאם פועל כרכיב שמפרסם הודעות, הוא מאזין להודעות HL7v2 שנוצרו או נקלטו במאגר HL7v2 באמצעות messages.create או messages.ingest. אחרי שיוצרים הודעה, נשלחת התראה של Pub/Sub למתאם, והמתאם מפרסם את ההודעות לנמען חיצוני.

בקטעים הבאים מוסבר איך להפעיל את המתאם כך שהוא יפעל כמקלט או כמפרסם.

אחרי שמוודאים שאפשר להריץ את מתאם MLLP במחשב המקומי, אפשר להמשיך לקטע הבא בנושא פריסת מתאם MLLP ב-Google Kubernetes Engine.

בדיקה מקומית של מתאם MLLP כמקלט

כשהמתאם מקבל הודעה של HL7v2 ממקור חיצוני, כמו מרכז טיפול, המתאם קורא ל-messages.ingest ומטמיע את ההודעה של HL7v2 במאגר HL7v2 שהוגדר. אפשר לראות את זה בקוד המקור של המתאם.

כדי לבדוק את המתאם באופן מקומי כמקלט, מבצעים את השלבים הבאים:

  1. במחשב שבו משכתם את קובץ האימג' של Docker שנבנה מראש, מריצים את הפקודה הבאה:

    docker run \
    --network=host \
    -v ~/.config:/root/.config \
    gcr.io/cloud-healthcare-containers/mllp-adapter \
    /usr/mllp_adapter/mllp_adapter \
    --hl7_v2_project_id=PROJECT_ID \
    --hl7_v2_location_id=LOCATION \
    --hl7_v2_dataset_id=DATASET_ID \
    --hl7_v2_store_id=HL7V2_STORE_ID \
    --export_stats=false \
    --receiver_ip=0.0.0.0 \
    --port=2575 \
    --api_addr_prefix=https://healthcare.googleapis.com:443/v1 \
    --logtostderr

    where:

    • ‫PROJECT_ID הוא המזהה של Google Cloud הפרויקט שמכיל את מאגר ה-HL7v2.
    • ‫LOCATION הוא האזור שבו נמצאת החנות שלכם ב-HL7v2.
    • ‫DATASET_ID הוא המזהה של מערך הנתונים הראשי של החנות ב-HL7v2.
    • ‫HL7V2_STORE_ID הוא המזהה של מאגר HL7v2 שאליו אתם שולחים הודעות HL7v2.

    אחרי שמריצים את הפקודה הקודמת, המתאם מדפיס הודעה שדומה להודעה הבאה ומתחיל לפעול במחשב המקומי בכתובת ה-IP ‏127.0.0.1 ביציאה 2575:

    I0000 00:00:00.000000      1 healthapiclient.go:171] Dialing connection to https://healthcare.googleapis.com:443/v1
I0000 00:00:00.000000      1 mllp_adapter.go:89] Either --pubsub_project_id or --pubsub_subscription is not provided, notifications of the new messages are not read and no outgoing messages will be sent to the target MLLP address.

    אם נתקלתם בשגיאות, תוכלו לפעול לפי השלבים הבאים לפתרון בעיות:

  2. כדי להמשיך בבדיקה בזמן שהמתאם פועל כתהליך בחזית, פותחים מסוף אחר במחשב המקומי.

  3. בטרמינל החדש, כדי להתקין את Netcat, מריצים את הפקודה הבאה:

    sudo apt install netcat

  4. מורידים את הקובץ hl7v2-mllp-sample.txt ושומרים אותו במחשב המקומי.

  5. כדי לשלוח את ההודעה בפורמט HL7v2 למתאם, מריצים את הפקודה הבאה בספרייה שבה הורדתם את הקובץ. מתאם MLLP מאזין למארח המקומי ביציאה 2575. הפקודה שולחת את ההודעה דרך מתאם MLLP אל מאגר HL7v2.

    Linux

    echo -n -e "\x0b$(cat hl7v2-mllp-sample.txt)\x1c\x0d" | nc -q1 localhost 2575 | less

    אם ההודעה נקלטה בהצלחה במאגר HL7v2, הפקודה תחזיר את הפלט הבא:

    ^KMSH|^~\&|TO_APP|TO_FACILITY|FROM_APP|FROM_FACILITY|19700101010000||ACK|c507a97e-438d-44b0-b236-ea95e5ecbbfb|P|2.5^MMSA|AA|20150503223000^\

    הפלט הזה מציין שהמאגר של HL7v2 הגיב עם סוג תגובה AA (Application Accept), כלומר ההודעה אומתה והוכנסה בהצלחה.

  6. אפשר גם לפתוח את הטרמינל שבו הפעלתם את המתאם כדי לוודא שההודעה נשלחה בהצלחה. הפלט אמור להיראות כמו בדוגמה הבאה:

     I0000 00:00:00.000000       1 healthapiclient.go:171] Dialing connection to https://healthcare.googleapis.com:443/v1
 I0000 00:00:00.000000       1 mllp_adapter.go:89] Either --pubsub_project_id or --pubsub_subscription is not provided, notifications of the new messages are not read and no outgoing messages will be sent to the target MLLP address.
 I0213 00:00:00.000000       1 healthapiclient.go:190] Sending message of size 319.
 I0213 00:00:00.000000       1 healthapiclient.go:223] Message was successfully sent.

  7. ההודעה מאוחסנת בחנות HL7v2, כך שאפשר להתקשר אל messages.list כדי להציג את ההודעה:

    curl

    curl -X GET \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages"

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

    {
  "hl7V2Messages": [
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID"
    }
  ]
}

    PowerShell

    $cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Get `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages" | Select-Object -Expand Content

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

    {
  "hl7V2Messages": [
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID"
    }
  ]
}

בדיקה מקומית של מתאם MLLP בתור מפרסם

כשבודקים את המתאם כמפיץ, יוצרים הודעות על ידי קריאה ל-messages.create או ל-messages.ingest ומספקים קובץ הודעה כנתונים בינאריים.

המתאם מאשר אוטומטית הודעות Pub/Sub שנשלחות דרך messages.create ו-messages.ingest.

המתאם שולח לכם הודעה כשהוא מאחזר ושולח הודעות Pub/Sub בהצלחה. המתאם הוא מנוי Pub/Sub, ולכן הוא מאשר את ההודעות האלה באופן אוטומטי. כתוצאה מכך, הן מוסרות מתור ההודעות במינוי Pub/Sub שהגדרתם באמצעות המתאם.

כדי לשלוף מהמינוי ל-Pub/Sub ולאמת בנפרד שההודעות פורסמו, צריך ליצור מינוי שני ל-Pub/Sub שמוקצה לנושא שיצרתם קודם. המתאם לא מאשר אוטומטית את ההודעות שנשלחות למינוי השני, והן נשמרות כדי שתוכלו לשלוף אותן.

כדי ליצור מינוי Pub/Sub שני שמוקצה לנושא שיצרתם קודם, מבצעים את הפעולות הבאות:

המסוף

  1. נכנסים לדף Topics של Pub/Sub במסוף Google Cloud .

    מעבר לדף הנושאים של Pub/Sub

  2. לוחצים על הנושא של הפרויקט. זהו הנושא שדרכו יצרת את המינוי הראשוני.

  3. לוחצים על יצירת מינוי.

  4. מזינים שם מינוי:

    projects/PROJECT_ID/subscriptions/SECOND_SUBSCRIPTION_NAME

    משאירים את ההגדרה סוג הצגת מודעות כשליפה.

  5. לוחצים על יצירה.

gcloud

כדי ליצור מינוי שני ל-Pub/Sub שמוקצה לנושא שיצרתם קודם, מריצים את הפקודה gcloud pubsub subscriptions create:

gcloud pubsub subscriptions create SECOND_SUBSCRIPTION_NAME --topic=projects/PROJECT_ID/topics/TOPIC_NAME

אם הבקשה מבוצעת בהצלחה, הפקודה תחזיר את הפלט הבא:

Created subscription [projects/PROJECT_ID/subscriptions/SECOND_SUBSCRIPTION_NAME].

כדי לבדוק את המתאם באופן מקומי כבעלי תוכן דיגיטלי, מבצעים את השלבים הבאים במחשב שבו משכתם את קובץ אימג' של Docker שנבנה מראש:

  1. מתקינים את Netcat:

    sudo apt install netcat

  2. מורידים את הקובץ hl7v2-mllp-ack-sample.txt ושומרים אותו במחשב המקומי. הקובץ מכיל הודעת אישור (ACK) שהמתאם דורש כתשובה כשהוא מנסה לפרסם הודעה.

  3. כדי לאפשר ל-Netcat להאזין לחיבורים נכנסים ביציאה 2525, מריצים את הפקודה הבאה בספרייה שבה הורדתם את הקובץ.

    Linux

    echo -n -e "\x0b$(cat hl7v2-mllp-ack-sample.txt)\x1c\x0d" | nc -q1 -lv -p 2525 | less

    אחרי שמפעילים את Netcat, מוצגת הודעת פלט שדומה לדוגמה הבאה:

    listening on [any] 2525 ...

  4. ‫Netcat פועל כתהליך בחזית, לכן כדי להמשיך בבדיקה, צריך לפתוח טרמינל אחר במחשב המקומי.

  5. כדי להפעיל את המתאם, בטרמינל החדש מריצים את הפקודה הבאה:

    docker run \
    --network=host \
    gcr.io/cloud-healthcare-containers/mllp-adapter \
    /usr/mllp_adapter/mllp_adapter \
    --hl7_v2_project_id=PROJECT_ID \
    --hl7_v2_location_id=LOCATION \
    --hl7_v2_dataset_id=DATASET_ID \
    --hl7_v2_store_id=HL7V2_STORE_ID \
    --export_stats=false \
    --receiver_ip=127.0.0.1 --port 2575 \
    --mllp_addr=127.0.0.1:2525 \
    --pubsub_project_id=PROJECT_ID \
    --pubsub_subscription=PUBSUB_SUBSCRIPTION \
    --api_addr_prefix=https://healthcare.googleapis.com:443/v1 \
    --logtostderr

    where:

    • ‫PROJECT_ID הוא המזהה של Google Cloud הפרויקט שמכיל את מאגר ה-HL7v2.
    • ‫LOCATION הוא האזור שבו נמצאת החנות שלכם ב-HL7v2.
    • ‫DATASET_ID הוא המזהה של מערך הנתונים הראשי של החנות ב-HL7v2.
    • ‫HL7V2_STORE_ID הוא המזהה של מאגר HL7v2 שאליו אתם שולחים הודעות HL7v2.
    • ‫PROJECT_ID הוא המזהה של הפרויקט Google Cloud שכולל את נושא ה-Pub/Sub.
    • ‫PUBSUB_SUBSCRIPTION הוא השם של המינוי הראשון שיצרתם שמשויך לנושא Pub/Sub. המתאם צורך הודעות מהמינוי הזה ומאשר אותן באופן אוטומטי, ולכן כדי להציג את ההודעות שפורסמו בנושא, צריך לשלוף הודעות מהמינוי השני שיצרתם קודם.

    אחרי שמריצים את הפקודה הקודמת, המתאם מתחיל לפעול במחשב המקומי בכתובת ה-IP‏ 127.0.0.1 ביציאה 2575.

    אם נתקלתם בשגיאות, תוכלו לפעול לפי השלבים הבאים לפתרון בעיות:

    המתאם פועל כתהליך בחזית, ולכן כדי להמשיך בבדיקה, צריך לפתוח טרמינל אחר במחשב המקומי.

  6. מורידים את הקובץ hl7v2-sample.json ושומרים אותו במחשב המקומי. בספרייה שבה הורדתם את הקובץ, קוראים לשיטה messages.create כדי ליצור את ההודעה במאגר HL7v2:

    curl

    כדי ליצור הודעה של HL7v2, שולחים בקשת POST ומציינים את הפרטים הבאים:

    • השם של קבוצת הנתונים הראשית
    • השם של החנות ב-HL7v2
    • הודעה
    • טוקן גישה

    בדוגמה הבאה מוצגת בקשת POST באמצעות curl וקובץ JSON לדוגמה בשם hl7v2-sample.json.

    curl -X POST \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     --data-binary @hl7v2-sample.json \
     "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages"

    אם הבקשה מצליחה, השרת מחזיר את התגובה בפורמט JSON:

    {
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
  "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZfEF8QXwyMDE4MDEwMTAwMDAwMHx8VFlQRV5BfDIwMTgwMTAxMDAwMDAwfFR8MC4wfHx8QUF8fDAwfEFTQ0lJDUVWTnxBMDB8MjAxODAxMDEwNDAwMDANUElEfHwxNAExMTFeXl5eTVJOfDExMTExMTExXl5eXk1STn4xMTExMTExMTExXl5eXk9SR05NQlI=",
  "sendFacility": "SEND_FACILITY",
  "sendTime": "2018-01-01T00:00:00Z",
  "messageType": "TYPE",
  "createTime": "1970-01-01T00:00:00Z",
  "patientIds": [
    {
      "value": "14\u0001111",
      "type": "MRN"
    },
    {
      "value": "11111111",
      "type": "MRN"
    },
    {
      "value": "1111111111",
      "type": "ORGNMBR"
    }
  ]
}

    PowerShell

    כדי ליצור הודעה של HL7v2, שולחים בקשת POST ומציינים את הפרטים הבאים:

    • השם של קבוצת הנתונים הראשית
    • השם של החנות ב-HL7v2
    • הודעה
    • טוקן גישה

    בדוגמה הבאה מוצגת בקשת POST באמצעות Windows PowerShell וקובץ JSON לדוגמה שנקרא hl7v2-sample.json.

    $cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Post `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -InFile hl7v2-sample.json `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages" | Select-Object -Expand Content

    אם הבקשה מצליחה, השרת מחזיר את התגובה בפורמט JSON:

    {
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
  "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZfEF8QXwyMDE4MDEwMTAwMDAwMHx8VFlQRV5BfDIwMTgwMTAxMDAwMDAwfFR8MC4wfHx8QUF8fDAwfEFTQ0lJDUVWTnxBMDB8MjAxODAxMDEwNDAwMDANUElEfHwxNAExMTFeXl5eTVJOfDExMTExMTExXl5eXk1STn4xMTExMTExMTExXl5eXk9SR05NQlI=",
  "sendFacility": "SEND_FACILITY",
  "sendTime": "2018-01-01T00:00:00Z",
  "messageType": "TYPE",
  "createTime": "1970-01-01T00:00:00Z",
  "patientIds": [
    {
      "value": "14\u0001111",
      "type": "MRN"
    },
    {
      "value": "11111111",
      "type": "MRN"
    },
    {
      "value": "1111111111",
      "type": "ORGNMBR"
    }
  ]
}

    אחרי שיוצרים את ההודעה, מתאם MLLP מחזיר תגובה שדומה לזו:

    I0214 00:00:00.000000       1 healthapiclient.go:244] Started to fetch message from the Cloud Healthcare API HL7V2 Store
I0214 00:00:00.000000       1 healthapiclient.go:283] Message was successfully fetched from the Cloud Healthcare API HL7V2 Store.

  7. בטרמינל שבו הפעלתם את Netcat, יוצג פלט שדומה לדוגמה הבאה: הפלט הזה מציין שההודעה פורסמה:

    connect to [127.0.0.1] from localhost [127.0.0.1] 39522
^KMSH|^~\&|A|SEND_FACILITY|A|A|20180101000000||TYPE^A|20180101000000|T|0.0|||AA||00|ASCII^MEVN|A00|20180101040000^MPID||14^A111^^^^MRN|11111111^^^^MRN~1111111111^^^^ORGNMBR^\

    הערך הזה תואם לערך בשדה data בתגובה שקיבלתם כשיצרתם את ההודעה. הערך כאן זהה לערך data בקובץ hl7v2-sample.json.

  8. כדי לראות את ההודעה שהמתאם פרסם בנושא Pub/Sub, מריצים את הפקודה gcloud pubsub subscriptions pull במינוי השני ל-Pub/Sub שיצרתם:

    gcloud pubsub subscriptions pull --auto-ack SECOND_SUBSCRIPTION

    הפקודה מחזירה את הפלט הבא לגבי הודעת HL7v2 שנוצרה. שימו לב לערך publish=true בעמודה ATTRIBUTES, שמציין שההודעה פורסמה ב-Pub/Sub:

    ┌-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┐
|                                                               DATA                                              |    MESSAGE_ID   |   ATTRIBUTES  |
├-----------------------------------------------------------------------------------------------------------------|-----------------|---------------|
| projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/HL7V2_MESSAGE_ID | 123456789012345 | msgType=ADT   |
|                                                                                                                 |                 | publish=true  |
└-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘

פרסום הודעות לנמענים חיצוניים שונים

אפשר להגדיר את מאגר HL7v2 עם כמה נושאי Pub/Sub ולהשתמש במסננים כדי לשלוח התראות לנושאים שונים ב-Pub/Sub. לאחר מכן, תוכלו להפעיל מתאם MLLP לכל נושא ב-Pub/Sub כדי לפרסם את ההודעות למקלט חיצוני אחר.

כדי להגדיר את מאגר HL7v2 עם כמה נושאי Pub/Sub ומסנן לכל נושא, צריך לבצע את השלבים הבאים:

  1. יוצרים שני נושאים ב-Pub/Sub ומינוי לכל נושא. מידע נוסף זמין במאמר בנושא יצירת נושא ומינוי ב-Pub/Sub.

  2. מריצים את הפקודה הבאה:

    curl

    curl -X PATCH \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    --data "{
      'notificationConfigs': [
          {
              'pubsubTopic': 'projects/PROJECT_ID/topics/PUBSUB_TOPIC',
              'filter' : 'sendFacility=\"SEND_FACILITY_1\"'
          },
          {
              'pubsubTopic': 'projects/PROJECT_ID/topics/SECOND_PUBSUB_TOPIC',
              'filter': 'sendFacility=\"SEND_FACILITY_2\"'
          }
      ]
    }" "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID?updateMask=notificationConfigs"

    אם הבקשה מצליחה, השרת מחזיר את התגובה בפורמט JSON:

    {
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID",
  "notificationConfigs": [
    {
      "pubsubTopic": "projects/PROJECT_ID/topics/PUBSUB_TOPIC",
      "filter": "sendFacility=\"SEND_FACILITY_1\""
    },
    {
      "pubsubTopic": "projects/PROJECT_ID/topics/SECOND_PUBSUB_TOPIC",
      "filter": "sendFacility=\"SEND_FACILITY_2\""
    }
  ]
}

    PowerShell

    $cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Patch `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -Body "{
      'notificationConfigs': [
        {
          'pubsubTopic' : 'projects/PROJECT_ID/topics/PUBSUB_TOPIC',
          'filter': 'sendFacility=\"SEND_FACILITY_1\"'
        },
        {
          'pubsubTopic' : 'projects/PROJECT_ID/topics/SECOND_PUBSUB_TOPIC',
          'filter' : 'sendFacility=\"SEND_FACILITY_2\"'
        }
      ]
  }" `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores?hl7V2StoreId=HL7V2_STORE_ID?updateMask=notificationConfigs" | Select-Object -Expand Content

    אם הבקשה מצליחה, השרת מחזיר את התגובה בפורמט JSON:

    {
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID",
  "notificationConfigs": [
    {
      "pubsubTopic": "projects/PROJECT_ID/topics/PUBSUB_TOPIC",
      "filter": "sendFacility=\"SEND_FACILITY_1\""
    },
    {
      "pubsubTopic": "projects/PROJECT_ID/topics/SECOND_PUBSUB_TOPIC",
      "filter": "sendFacility=\"SEND_FACILITY_2\""
    }
  ]
}

בדיקת ניתוב ההודעות

כדי לבדוק את ניתוב ההודעות, צריך לבצע את השלבים בקטעים הבאים.

הגדרה והפעלה של המקלט והמתאם הראשונים

כדי להגדיר ולהפעיל את המקלט והמתאם הראשונים, מבצעים את השלבים הבאים:

  1. במכונה שבה משכתם את קובץ אימג' של Docker שנבנה מראש, מריצים את הפקודה הבאה כדי להתקין את Netcat:

    sudo apt install netcat

  2. אם עדיין לא עשיתם את זה, הורידו את hl7v2-mllp-ack-sample.txt. הקובץ מכיל הודעת ACK שמשמשת כתגובה של המתאם כשהוא מנסה לפרסם הודעה.

  3. כדי להגדיר את יציאה 2525 לנמען הראשון, מריצים את הפקודה הבאה:

    Linux

    echo -n -e "\x0b$(cat hl7v2-mllp-ack-sample.txt)\x1c\x0d" | nc -q1 -lv -p 2525 | less

    כשמתחיל תהליך Netcat, מוצג הפלט הבא:

    listening on [any] 2525 ...

  4. כדי להפעיל את המתאם הראשון, מריצים את הפקודה הבאה בטרמינל חדש:

    docker run \
    --network=host \
    gcr.io/cloud-healthcare-containers/mllp-adapter \
    /usr/mllp_adapter/mllp_adapter \
    --hl7_v2_project_id=PROJECT_ID \
    --hl7_v2_location_id=LOCATION \
    --hl7_v2_dataset_id=DATASET_ID \
    --hl7_v2_store_id=HL7V2_STORE_ID \
    --export_stats=false \
    --receiver_ip=127.0.0.1 --port 2575 \
    --mllp_addr=127.0.0.1:2525 \
    --pubsub_project_id=PROJECT_ID \
    --pubsub_subscription=PUBSUB_SUBSCRIPTION \
    --api_addr_prefix=https://healthcare.googleapis.com:443/v1 \
    --logtostderr

    where:

    • ‫PROJECT_ID הוא המזהה של Google Cloud הפרויקט שמכיל את מאגר ה-HL7v2.
    • ‫LOCATION הוא האזור שבו נמצאת החנות שלכם ב-HL7v2.
    • ‫DATASET_ID הוא המזהה של מערך הנתונים הראשי של החנות ב-HL7v2.
    • ‫HL7V2_STORE_ID הוא המזהה של מאגר HL7v2 שאליו אתם שולחים הודעות HL7v2.
    • ‫PROJECT_ID הוא המזהה של הפרויקט Google Cloud שכולל את נושא ה-Pub/Sub.
    • ‫PUBSUB_SUBSCRIPTION הוא השם של המינוי הראשון שיצרתם שמשויך לנושא הראשון של Pub/Sub. המתאם צורך הודעות מהמינוי הזה ומאשר אותן באופן אוטומטי.

    אחרי שמריצים את הפקודה הזו, המתאם מתחיל לפעול במכונה המקומית בכתובת 127.0.0.1:2575. הוא מפרסם הודעות חדשות לנמען החיצוני הראשון ביציאה 2525.

הגדרת המקלט והמתאם השני והפעלתם

כדי להגדיר ולהפעיל את המקלט והמתאם השני, מבצעים את השלבים הבאים:

  1. במחשב שבו משכתם את קובץ אימג' של Docker שנבנה מראש, מריצים את הפקודה הבאה כדי להתקין את Netcat:

    sudo apt install netcat

  2. אם עדיין לא עשיתם את זה, הורידו את hl7v2-mllp-ack-sample.txt. הקובץ מכיל הודעת ACK שמשמשת כתגובה של המתאם כשהוא מנסה לפרסם הודעה.

  3. כדי להגדיר את יציאה 2526 למקלט השני, מריצים את הפקודה הבאה.

    Linux

    echo -n -e "\x0b$(cat hl7v2-mllp-ack-sample.txt)\x1c\x0d" | nc -q1 -lv -p 2526 | less

    כשמתחיל תהליך Netcat, מוצג הפלט הבא:

    listening on [any] 2526 ...

  4. כדי להפעיל את המתאם השני, מריצים את הפקודה הבאה בטרמינל חדש:

    docker run \
    --network=host \
    gcr.io/cloud-healthcare-containers/mllp-adapter \
    /usr/mllp_adapter/mllp_adapter \
    --hl7_v2_project_id=PROJECT_ID \
    --hl7_v2_location_id=LOCATION \
    --hl7_v2_dataset_id=DATASET_ID \
    --hl7_v2_store_id=HL7V2_STORE_ID \
    --export_stats=false \
    --receiver_ip=127.0.0.1 --port 2576 \
    --mllp_addr=127.0.0.1:2526 \
    --pubsub_project_id=PROJECT_ID \
    --pubsub_subscription=SECOND_PUBSUB_SUBSCRIPTION \
    --api_addr_prefix=https://healthcare.googleapis.com:443/v1 \
    --logtostderr

    where:

    • ‫PROJECT_ID הוא המזהה של Google Cloud הפרויקט שמכיל את מאגר ה-HL7v2.
    • ‫LOCATION הוא האזור שבו נמצאת החנות שלכם ב-HL7v2.
    • ‫DATASET_ID הוא המזהה של מערך הנתונים הראשי של החנות ב-HL7v2.
    • ‫HL7V2_STORE_ID הוא המזהה של מאגר HL7v2 שאליו אתם שולחים הודעות HL7v2.
    • ‫PROJECT_ID הוא המזהה של הפרויקט Google Cloud שכולל את נושא ה-Pub/Sub.
    • ‫SECOND_PUBSUB_SUBSCRIPTION הוא השם של המינוי השני שיצרתם שמשויך לנושא השני של Pub/Sub. המתאם צורך הודעות מהמינוי הזה ומאשר אותן באופן אוטומטי.

    אחרי הרצת הפקודה הזו, המתאם מתחיל לפעול במכונה המקומית בכתובת ה-IP 127.0.0.1:2576. הוא מפרסם הודעות חדשות למקלט החיצוני השני ביציאה 2526.

פרסום הודעה לנמען הראשון

כדי ליצור הודעה שתפורסם רק לנמען החיצוני הראשון, מבצעים את השלבים הבאים:

  1. מורידים את hl7v2-sample1.json.

  2. בספרייה שבה הורדתם את hl7v2-sample1.json, קוראים לשיטה messages.create כדי ליצור את ההודעה במאגר HL7v2:

    curl

    כדי ליצור הודעה של HL7v2, שולחים בקשת POST ומציינים את הפרטים הבאים:

    • השם של קבוצת הנתונים הראשית
    • השם של החנות ב-HL7v2
    • הודעה
    • טוקן גישה

    בדוגמה הבאה מוצגת בקשת POST באמצעות curl וקובץ JSON לדוגמה, hl7v2-sample1.json.

    curl -X POST \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    --data-binary @hl7v2-sample1.json \
    "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages"

    אם הבקשה מצליחה, השרת מחזיר את התגובה בפורמט JSON:

    {
 "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
 "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZXzF8QXxBfDIwMTgwMTAxMDAwMDAwfHxUWVBFXkF8MjAxODAxMDEwMDAwMDB8VHwwLjB8fHxBQXx8MDB8QVNDSUkNRVZOfEEwMHwyMDE4MDEwMTA0MDAwMA1QSUR8fDE0ATExMV5eXl5NUk58MTExMTExMTFeXl5eTVJOfjExMTExMTExMTFeXl5eT1JHTk1CUg==",
 "sendFacility": "SEND_FACILITY_1",
 "sendTime": "2018-01-01T00:00:00Z",
 "messageType": "TYPE",
 "createTime": "1970-01-01T00:00:00Z",
 "patientIds": [
   {
     "value": "14\u0001111",
     "type": "MRN"
   },
   {
     "value": "11111111",
     "type": "MRN"
   },
   {
     "value": "1111111111",
     "type": "ORGNMBR"
   }
 ]
}

    PowerShell

    כדי ליצור הודעה של HL7v2, שולחים בקשת POST ומציינים את הפרטים הבאים:

    • השם של קבוצת הנתונים הראשית
    • השם של החנות ב-HL7v2
    • הודעה
    • טוקן גישה

    בדוגמה הבאה מוצגת בקשת POST באמצעות Windows PowerShell וקובץ JSON לדוגמה שנקרא hl7v2-sample1.json.

    $cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
 -Method Post `
 -Headers $headers `
 -ContentType: "application/json; charset=utf-8" `
 -InFile hl7v2-sample1.json `
 -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages" | Select-Object -Expand Content

    אם הבקשה מצליחה, השרת מחזיר את התגובה בפורמט JSON:

    {
 "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
 "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZXzF8QXxBfDIwMTgwMTAxMDAwMDAwfHxUWVBFXkF8MjAxODAxMDEwMDAwMDB8VHwwLjB8fHxBQXx8MDB8QVNDSUkNRVZOfEEwMHwyMDE4MDEwMTA0MDAwMA1QSUR8fDE0ATExMV5eXl5NUk58MTExMTExMTFeXl5eTVJOfjExMTExMTExMTFeXl5eT1JHTk1CUg==",
 "sendFacility": "SEND_FACILITY_1",
 "sendTime": "2018-01-01T00:00:00Z",
 "messageType": "TYPE",
 "createTime": "1970-01-01T00:00:00Z",
 "patientIds": [
   {
     "value": "14\u0001111",
     "type": "MRN"
   },
   {
     "value": "11111111",
     "type": "MRN"
   },
   {
     "value": "1111111111",
     "type": "ORGNMBR"
   }
 ]
}

    בתגובה הזו, הערך של sendFacility מוגדר כ-SEND_FACILITY_1, ולכן ההתראה ב-Pub/Sub נשלחת רק לנושא הראשון ב-Pub/Sub. אחרי יצירת ההודעה, מתאם ה-MLLP הראשון מחזיר את התגובה הבאה:

    I0214 00:00:00.000000       1 healthapiclient.go:266] Started to fetch message.
I0214 00:00:00.000000       1 healthapiclient.go:283] Message was successfully fetched.

    המתאם השני של MLLP לא מחזיר תגובה כי לא נשלחת הודעה לנושא השני של Pub/Sub.

    במסוף שבו הפעלתם את התהליך הראשון של Netcat, מוצגת הפלט הבא. הפלט הזה מציין שההודעה פורסמה.

    connect to [127.0.0.1] from localhost [127.0.0.1] 39522
^KMSH|^~\&|A|SEND_FACILITY_1|A|A|20180101000000||TYPE^A|20180101000000|T|0.0|||AA||00|ASCII^MEVN|A00|20180101040000^MPID||14^A111^^^^MRN|11111111^^^^MRN~1111111111^^^^ORGNMBR^\

    הפלט הזה תואם לערך בשדה data בתגובה שקיבלתם כשיצרתם את ההודעה. הערך כאן זהה לערך data בקובץ hl7v2-sample1.json.

פרסום הודעה במקלט השני

כדי ליצור הודעה שתפורסם רק אצל הנמען החיצוני השני, מבצעים את השלבים הבאים:

  1. פותחים טרמינל חדש במחשב המקומי.

  2. כדי ליצור הודעה שתפורסם רק אצל הנמען החיצוני השני, מורידים את hl7v2-sample2.json.

  3. בספרייה שבה הורדתם את hl7v2-sample2.json, קוראים לשיטה messages.create כדי ליצור את ההודעה במאגר HL7v2:

    curl

    כדי ליצור הודעה של HL7v2, שולחים בקשת POST ומציינים את הפרטים הבאים:

    • השם של קבוצת הנתונים הראשית
    • השם של החנות ב-HL7v2
    • הודעה
    • טוקן גישה

    בדוגמה הבאה מוצגת בקשת POST באמצעות curl וקובץ JSON לדוגמה, hl7v2-sample2.json.

    curl -X POST \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    --data-binary @hl7v2-sample2.json \
    "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages"

    אם הבקשה מצליחה, השרת מחזיר את התגובה בפורמט JSON:

    {
 "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
 "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZXzJ8QXxBfDIwMTgwMTAxMDAwMDAwfHxUWVBFXkF8MjAxODAxMDEwMDAwMDB8VHwwLjB8fHxBQXx8MDB8QVNDSUkNRVZOfEEwMHwyMDE4MDEwMTA0MDAwMA1QSUR8fDE0ATExMV5eXl5NUk58MTExMTExMTFeXl5eTVJOfjExMTExMTExMTFeXl5eT1JHTk1CUg==",
 "sendFacility": "SEND_FACILITY_2",
 "sendTime": "2018-01-01T00:00:00Z",
 "messageType": "TYPE",
 "createTime": "1970-01-01T00:00:00Z",
 "patientIds": [
   {
     "value": "14\u0001111",
     "type": "MRN"
   },
   {
     "value": "11111111",
     "type": "MRN"
   },
   {
     "value": "1111111111",
     "type": "ORGNMBR"
   }
 ]
}

    PowerShell

    כדי ליצור הודעה של HL7v2, שולחים בקשת POST ומציינים את הפרטים הבאים:

    • השם של קבוצת הנתונים הראשית
    • השם של החנות ב-HL7v2
    • הודעה
    • טוקן גישה

    בדוגמה הבאה מוצגת בקשת POST באמצעות Windows PowerShell וקובץ JSON לדוגמה, hl7v2-sample2.json.

    $cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
 -Method Post `
 -Headers $headers `
 -ContentType: "application/json; charset=utf-8" `
 -InFile hl7v2-sample2.json `
 -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages" | Select-Object -Expand Content

    אם הבקשה מצליחה, השרת מחזיר את התגובה בפורמט JSON:

    {
 "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
 "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZXzJ8QXxBfDIwMTgwMTAxMDAwMDAwfHxUWVBFXkF8MjAxODAxMDEwMDAwMDB8VHwwLjB8fHxBQXx8MDB8QVNDSUkNRVZOfEEwMHwyMDE4MDEwMTA0MDAwMA1QSUR8fDE0ATExMV5eXl5NUk58MTExMTExMTFeXl5eTVJOfjExMTExMTExMTFeXl5eT1JHTk1CUg==",
 "sendFacility": "SEND_FACILITY_2",
 "sendTime": "2018-01-01T00:00:00Z",
 "messageType": "TYPE",
 "createTime": "1970-01-01T00:00:00Z",
 "patientIds": [
   {
     "value": "14\u0001111",
     "type": "MRN"
   },
   {
     "value": "11111111",
     "type": "MRN"
   },
   {
     "value": "1111111111",
     "type": "ORGNMBR"
   }
 ]
}

    שימו לב: הערך של sendFacility הוא SEND_FACILITY_2, ולכן ההתראה של Pub/Sub נשלחת רק לנושא השני של Pub/Sub. אחרי יצירת ההודעה, מתאם MLLP הראשון לא מחזיר תגובה, בעוד שמתאם MLLP השני מחזיר את התגובה הבאה:

    I0214 00:00:00.000000       1 healthapiclient.go:266] Started to fetch message.
I0214 00:00:00.000000       1 healthapiclient.go:283] Message was successfully fetched.

    במסוף שבו הפעלתם את תהליך Netcat השני, מוצגת הפלט הבא. הפלט הזה מציין שההודעה פורסמה.

    connect to [127.0.0.1] from localhost [127.0.0.1] 39522
^KMSH|^~\&|A|SEND_FACILITY_2|A|A|20180101000000||TYPE^A|20180101000000|T|0.0|||AA||00|ASCII^MEVN|A00|20180101040000^MPID||14^A111^^^^MRN|11111111^^^^MRN~1111111111^^^^ORGNMBR^\

    הפלט הזה תואם לערך בשדה data בתגובה שקיבלתם כשיצרתם את ההודעה. הערך כאן זהה לערך data בקובץ hl7v2-sample2.json.

פריסת מתאם MLLP ב-Google Kubernetes Engine

כשמעבירים הודעות HL7v2 דרך MLLP ממרכז הטיפול, אפשר להגדיר את ההודעות כך שיישלחו למתאם שמוטמע ב-Google Cloud ויכול להעביר אותן ל-Cloud Healthcare API.

מתאם MLLP פועל כאפליקציה ללא מצב באשכול GKE. אשכול GKE הוא קבוצה מנוהלת של מופעי מכונות וירטואליות להרצת אפליקציות בקונטיינרים. אפליקציות בלי שמירת מצב הן אפליקציות שלא שומרות נתונים או מצב אפליקציה באשכול או באחסון מתמיד. במקום זאת, הנתונים ומצב האפליקציה נשארים אצל הלקוח, מה שהופך אפליקציות בלי שמירת מצב לניתנות להרחבה יותר.

‫GKE משתמש בבקר Deployment כדי לפרוס אפליקציות בלי שמירת מצב בתור Pods אחידים ולא ייחודיים. פריסות מנהלות את המצב הרצוי של האפליקציה: כמה פודים צריכים להריץ את האפליקציה, איזו גרסה של קובץ האימג' של הקונטיינר צריכה לפעול, איך צריך לתייג את הפודים וכו'. אפשר לשנות את המצב הרצוי באופן דינמי באמצעות עדכונים של מפרט ה-Pod של הפריסה.

במקביל לפריסת המתאם, יוצרים בקר Service שמאפשר לחבר את המתאם ל-Cloud Healthcare API באמצעות איזון עומסים פנימי.

אם אתם חדשים ב-GKE, מומלץ לעבור על המדריך לתחילת העבודה עם GKE כדי להבין איך המוצר פועל.

הוספת הרשאות ל-Pub/Sub API לחשבון השירות של GKE

כפי שמצוין במסמכי GKE בנושא אימות ב-Cloud Platform באמצעות חשבונות שירות, כל צומת באוסף קונטיינרים הוא מופע של Compute Engine. לכן, כשהמתאם של MLLP פועל באוסף של קונטיינרים, הוא מקבל באופן אוטומטי את ההיקפים של המכונות ב-Compute Engine שבהן הוא נפרס.

Google Cloud יוצר באופן אוטומטי חשבון שירות בשם Compute Engine default service account, ו-GKE משייך את חשבון השירות הזה לצמתים ש-GKE יוצר. בהתאם לאופן שבו הפרויקט מוגדר, יכול להיות שלחשבון השירות שמוגדר כברירת מחדל יש הרשאות להשתמש בממשקי API אחרים של Cloud Platform, ויכול להיות שלא. בנוסף, מערכת GKE מקצה היקפי גישה מוגבלים למכונות Compute Engine.

כדי לקבל את התוצאות הטובות ביותר, אל תבצעו אימות לשירותים אחרים Google Cloud (כמו Pub/Sub) מ-Pods שפועלים ב-GKE על ידי עדכון ההרשאות של חשבון השירות שמוגדר כברירת מחדל או הקצאת היקפי גישה נוספים למופעי Compute Engine. במקום זאת, אפשר ליצור חשבונות שירות משלכם.

צריך להעניק את ההרשאות הנדרשות ל-Pub/Sub לאשכול של מאגרי התגים, אבל יש גם אפשרות להעניק הרשאות לכתיבת מדדים ל-Cloud Monitoring.

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

המסוף

יוצרים חשבון שירות:

  1. במסוף Google Cloud , נכנסים לדף יצירת חשבון שירות.

    כניסה לדף Create service account

  2. בוחרים פרויקט.

  3. כותבים שם בשדה Service account name. השדה Service account ID ימולא במסוףGoogle Cloud בהתאם לשם הזה.

    אופציונלי: בשדה תיאור חשבון השירות, מזינים תיאור.

  4. לוחצים על יצירה.

  5. לוחצים על השדה בחירת תפקיד.

    בקטע All roles (כל התפקידים), לוחצים על Pub/Sub > Pub/Sub Subscriber (מינוי ל-Pub/Sub).

  6. לוחצים על Add another role ואז על השדה Select a role.

    בקטע All roles (כל התפקידים), לוחצים על Cloud Healthcare (שירותי בריאות בענן) > Healthcare HL7v2 Message Ingest (הטמעה של הודעות Healthcare HL7v2).

  7. אופציונלי: אם רוצים להפעיל מעקב, לוחצים על Add another role ואז על השדה Select a role.

    בקטע All roles, לוחצים על Monitoring > Monitoring Metric Writer.

  8. לוחצים על Continue.

  9. לוחצים על Done כדי לסיים ליצור את חשבון השירות.

    חשוב לא לסגור את חלון הדפדפן. תשתמשו בחלון הזה גם בשלב הבא.

gcloud

  1. כדי ליצור את חשבון השירות, מריצים את הפקודה gcloud iam service-accounts create.

    gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

    הפלט הוא חשבון השירות:

    Created service account SERVICE_ACCOUNT_NAME.

  2. כדי להקצות כל תפקיד לחשבון השירות, מריצים את הפקודה gcloud projects add-iam-policy-binding.

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/pubsub.subscriber

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/healthcare.hl7V2Ingest

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.metricWriter

    הפלט כולל את המדיניות המעודכנת:

    bindings:
    - members:
        - user:SERVICE_ACCOUNT_NAME
        role: roles/pubsub.publisher
    - members:
        - user:SERVICE_ACCOUNT_NAME
        roles/healthcare.hl7V2Ingest
    - members:
        - user:SERVICE_ACCOUNT_NAME
        roles/monitoring.metricWriter
    etag: ETAG
    version: 1

יצירת האשכול

כדי ליצור את האשכול ב-GKE, מריצים את הפקודה gcloud container clusters create:

gcloud container clusters create mllp-adapter \
    --zone=COMPUTE_ZONE \
    --service-account CLIENT_EMAIL

where:

  • ‫COMPUTE_ZONE הוא האזור שבו האשכול נפרס. תחום הוא מיקום אזורי משוער שבו נמצאים האשכולות והמשאבים שלהם. לדוגמה, us-west1-a הוא אזור באזור us-west. אם הגדרתם אזור ברירת מחדל באמצעות gcloud config set compute/zone, הערך של הדגל הזה מבטל את ברירת המחדל.
  • ‫CLIENT_EMAIL הוא המזהה של חשבון השירות שבו רוצים להשתמש. הפורמט הוא SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.

הפלט של הפקודה אמור להיראות כך:

Creating cluster mllp-adapter in COMPUTE_ZONE...
Cluster is being configured...
Cluster is being deployed...
Cluster is being health-checked...
Cluster is being health-checked (master is healthy)...done.
Created [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/COMPUTE_ZONE/clusters/mllp-adapter].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/COMPUTE_ZONE/mllp-adapter?project=PROJECT_ID
kubeconfig entry generated for mllp-adapter.
NAME          LOCATION       MASTER_VERSION  MASTER_IP      MACHINE_TYPE   NODE_VERSION  NUM_NODES  STATUS
mllp-adapter  COMPUTE_ZONE   1.11.7-gke.4    203.0.113.1    n1-standard-1  1.11.7-gke.4  3          RUNNING

אחרי שיוצרים את האשכול, GKE יוצר שלוש מכונות וירטואליות של Compute Engine. כדי לוודא את זה, מריצים את הפקודה הבאה כדי להציג את רשימת המופעים:

gcloud compute instances list

הגדרת הפריסה

כשפורסים אפליקציה ב-GKE, מגדירים מאפיינים של הפריסה באמצעות קובץ מניפסט של פריסה, שהוא בדרך כלל קובץ YAML. דוגמה מופיעה במאמר יצירת פריסה.

  1. פותחים טרמינל נפרד.

  2. באמצעות כלי לעריכת טקסט, יוצרים קובץ מניפסט לפריסה בשם mllp_adapter.yaml עם התוכן הבא:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mllp-adapter-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mllp-adapter
  template:
    metadata:
      labels:
        app: mllp-adapter
    spec:
      containers:
        - name: mllp-adapter
          imagePullPolicy: Always
          image: gcr.io/cloud-healthcare-containers/mllp-adapter
          ports:
            - containerPort: 2575
              protocol: TCP
              name: "port"
          command:
            - "/usr/mllp_adapter/mllp_adapter"
            - "--port=2575"
            - "--hl7_v2_project_id=PROJECT_ID"
            - "--hl7_v2_location_id=LOCATION"
            - "--hl7_v2_dataset_id=DATASET_ID"
            - "--hl7_v2_store_id=HL7V2_STORE_ID"
            - "--api_addr_prefix=https://healthcare.googleapis.com:443/v1"
            - "--logtostderr"
            - "--receiver_ip=0.0.0.0"

where:

  • ‫PROJECT_ID הוא המזהה של Google Cloud הפרויקט שמכיל את מאגר ה-HL7v2.
  • ‫LOCATION הוא האזור שבו נמצאת החנות שלכם ב-HL7v2.
  • ‫DATASET_ID הוא המזהה של מערך הנתונים הראשי של החנות ב-HL7v2.
  • ‫HL7V2_STORE_ID הוא המזהה של מאגר HL7v2 שאליו אתם שולחים הודעות HL7v2.

לפריסה יש את המאפיינים הבאים:

  • ‫spec: replicas: הוא מספר ה-Pods המשוכפלים שהפריסה מנהלת.
  • ‫spec: template: metadata: labels: היא התווית שניתנת לכל Pod, והפריסה משתמשת בה כדי לנהל את ה-Pods.
  • ‫spec: template: spec: הוא מפרט הפוד, שמגדיר איך כל פוד צריך לפעול.
  • ‫spec: containers כולל את שם הקונטיינר להרצה בכל Pod ואת קובץ האימג' של הקונטיינר שצריך להריץ.

מידע נוסף על מפרט הפריסה זמין במאמר הפניית API של Deployment.

הגדרת השירות

כדי שאפליקציות מחוץ לאשכול יוכלו לגשת למתאם MLLP (למשל, מרכז טיפול), צריך להגדיר מאזן עומסים פנימי.

אם לא הגדרתם VPN, אפליקציות יכולות לגשת למתאם MLLP דרך מאזן העומסים הפנימי, כל עוד האפליקציות משתמשות באותה רשת VPC ונמצאות באותו אזור Google Cloud . לדוגמה, כדי שהמתאם יהיה נגיש למכונה וירטואלית ב-Compute Engine באותו אזור ובאותה רשת VPC, אפשר להוסיף מאזן עומסים פנימי למשאב Service של האשכול.

בתיקייה שבה יצרתם את קובץ מניפסט הפריסה, משתמשים בכלי לעריכת טקסט כדי ליצור קובץ מניפסט של שירות בשם mllp_adapter_service.yaml עם התוכן הבא. הקובץ הזה אחראי להגדרת איזון עומסים פנימי:

apiVersion: v1
kind: Service
metadata:
  name: mllp-adapter-service
  annotations:
    cloud.google.com/load-balancer-type: "Internal"
spec:
  type: LoadBalancer
  ports:
  - name: port
    port: 2575
    targetPort: 2575
    protocol: TCP
  selector:
    app: mllp-adapter

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

  • ‫metadata: name: הוא השם שבחרתם לשירות. בדוגמה הזו, זה mllp-adapter-service.
  • ‫metadata: annotations: היא הערה שמציינת שצריך להגדיר מאזן עומסים פנימי.
  • ‫spec: type: הוא סוג מאזן העומסים.
  • המאפיין ports: port: משמש לציון היציאה שדרכה השירות יכול לקבל תעבורה משירותים אחרים באותו אשכול. היציאה של MLLP שמוגדרת כברירת מחדל 2575 נמצאת בשימוש.
  • ‫ports: targetPort: משמש לציון היציאה בכל Pod שבו השירות פועל.
  • ‫spec: selector: app: מציין את ה-Pods שהשירות מכוון אליהם.

אפשר לציין כתובת IP למאזן העומסים (באמצעות השדה clusterIP), אבל מאזן העומסים יכול ליצור כתובת IP משלו שאליה אפשר לשלוח הודעות. בשלב הזה, מאפשרים לאשכול ליצור את כתובת ה-IP, שתשמש אתכם בהמשך המדריך הזה.

מידע נוסף על איזון עומסים פנימי זמין במסמכי התיעוד של GKE.

מידע נוסף על מפרט השירות זמין בהפניית Service API.

פריסת הפריסה

כדי לפרוס את המתאם לאשכול GKE, מריצים את הפקודה הבאה בספרייה שמכילה את קובץ המניפסט של הפריסה mllp_adapter.yaml:

kubectl apply -f mllp_adapter.yaml

הפקודה מחזירה את הפלט הבא:

‫
deployment.extensions "mllp-adapter-deployment" created

בדיקת הפריסה

אחרי שיוצרים את הפריסה, אפשר להשתמש בכלי kubectl כדי לבדוק אותה.

כדי לקבל מידע מפורט על הפריסה, מריצים את הפקודה הבאה:

kubectl describe deployment mllp-adapter

כדי להציג את רשימת ה-Pods שנוצרו על ידי הפריסה, מריצים את הפקודה הבאה:

kubectl get pods -l app=mllp-adapter

כדי לקבל מידע על ה-Pod שנוצר:

kubectl describe pod POD_NAME

אם הפריסה בוצעה בהצלחה, החלק האחרון של הפלט מהפקודה הקודמת אמור להכיל את המידע הבא:

Events:
  Type    Reason     Age   From                                                  Message
  ----    ------     ----  ----                                                  -------
  Normal  Scheduled  1m    default-scheduler                                     Successfully assigned default/mllp-adapter-deployment-85b46f8-zxw68 to gke-mllp-adapter-default-pool-9c42852d-95sn
  Normal  Pulling    1m    kubelet, gke-mllp-adapter-default-pool-9c42852d-95sn  pulling image "gcr.io/cloud-healthcare-containers/mllp-adapter"
  Normal  Pulled     1m    kubelet, gke-mllp-adapter-default-pool-9c42852d-95sn  Successfully pulled image "gcr.io/cloud-healthcare-containers/mllp-adapter"
  Normal  Created    1m    kubelet, gke-mllp-adapter-default-pool-9c42852d-95sn  Created container
  Normal  Started    1m    kubelet, gke-mllp-adapter-default-pool-9c42852d-95sn  Started container

פריסת השירות ויצירת מאזן עומסים פנימי

כדי ליצור את איזון העומסים הפנימי, מריצים את הפקודה הבאה בספרייה שמכילה את קובץ המניפסט של שירות mllp_adapter_service.yaml:

kubectl apply -f mllp_adapter_service.yaml

הפקודה מחזירה את הפלט הבא:

‫
service "mllp-adapter-service" created

בדיקת השירות

אחרי שיוצרים את השירות, בודקים אותו כדי לוודא שהוא הוגדר בהצלחה.

כדי לבדוק את מאזן העומסים הפנימי, מריצים את הפקודה הבאה:

kubectl describe service mllp-adapter-service

הפלט של הפקודה אמור להיראות כך:

Name:                     mllp-adapter-service
Namespace:                default
Labels:                   <none>
Annotations:              cloud.google.com/load-balancer-type=Internal
                          kubectl.kubernetes.io/last-applied-configuration={"apiVersion":"v1","kind":"Service","metadata":{"annotations":{"cloud.google.com/load-balancer-type":"Internal"},"name":"mllp-adapter-service","namespa...
Selector:                 app=mllp-adapter
Type:                     LoadBalancer
IP:                       203.0.113.1
LoadBalancer Ingress:     203.0.113.1
Port:                     port  2575/TCP
TargetPort:               2575/TCP
NodePort:                 port  30660/TCP
Endpoints:                <none>
Session Affinity:         None
External Traffic Policy:  Cluster
Events:
  Type    Reason                Age   From                Message
  ----    ------                ----  ----                -------
  Normal  EnsuringLoadBalancer  1m    service-controller  Ensuring load balancer
  Normal  EnsuredLoadBalancer   1m    service-controller  Ensured load balancer

יכול להיות שיעברו עד דקה עד שכתובת ה-IP של LoadBalancer Ingress תופיע. בשלב הבא תשתמשו בכתובת ה-IP הזו ובפורט 2575 כדי לגשת לשירות מחוץ לאשכול.

יצירת מכונה וירטואלית ב-Compute Engine ושליחת הודעות

בשלב מוקדם יותר במדריך הזה בדקתם את מתאם MLLP באופן מקומי ושלחתם הודעות HL7v2 למאגר HL7v2. עכשיו תשלחו הודעות ממכונה וירטואלית ב-Compute Engine למתאם MLLP שפועל ב-GKE. ההודעות מועברות לחנות HL7v2.

כדי לשלוח בקשות מהמופע החדש לאשכול GKE, המופע והמופעים הקיימים צריכים להיות באותו אזור ולהשתמש באותה רשת VPC.

בסוף הקטע הזה תופיע רשימה של ההתראות שפורסמו בנושא ה-Pub/Sub ושל ההודעות של HL7v2 במאגר HL7v2. צריך להעניק למכונה וירטואלית ב-Compute Engine הרשאות לביצוע המשימות האלה. לפני שיוצרים את המכונה, יוצרים חשבון שירות חדש עם ההרשאות הנדרשות. כדי לעשות את זה, מבצעים את הפעולות הבאות:

המסוף

יוצרים חשבון שירות:

  1. במסוף Google Cloud , נכנסים לדף יצירת חשבון שירות.

    כניסה לדף Create service account

  2. בוחרים פרויקט.

  3. כותבים שם בשדה Service account name. השדה Service account ID ימולא במסוףGoogle Cloud בהתאם לשם הזה.

    אופציונלי: בשדה תיאור חשבון השירות, מזינים תיאור.

  4. לוחצים על יצירה.

  5. לוחצים על השדה בחירת תפקיד.

    בקטע All roles (כל התפקידים), לוחצים על Pub/Sub > Pub/Sub Subscriber (מינוי ל-Pub/Sub).

  6. לוחצים על Add another role ואז על השדה Select a role.

    בקטע All roles, לוחצים על Cloud Healthcare > Healthcare HL7v2 Message Consumer.

  7. לוחצים על Continue.

  8. לוחצים על Done כדי לסיים ליצור את חשבון השירות.

    חשוב לא לסגור את חלון הדפדפן. תשתמשו בחלון הזה גם בשלב הבא.

gcloud

  1. כדי ליצור את חשבון השירות, מריצים את הפקודה gcloud iam service-accounts create.

    gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

    הפלט הוא חשבון השירות:

    Created service account SERVICE_ACCOUNT_NAME.

  2. כדי להקצות כל תפקיד לחשבון השירות, מריצים את הפקודה gcloud projects add-iam-policy-binding.

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/pubsub.publisher

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/healthcare.hl7V2Consumer

    הפלט כולל את המדיניות המעודכנת:

    bindings:
    - members:
        - user:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
        role: roles/pubsub.publisher
    - members:
        - user:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
        roles/healthcare.hl7V2Consumer
    etag: ETAG
    version: 1

בשלבים הבאים מוסבר איך ליצור מכונה וירטואלית של Linux ב-Compute Engine:

המסוף

  1. נכנסים לדף VM Instances במסוף Google Cloud .

    כניסה לדף VM Instances

  2. לוחצים על Create instance.

  3. בוחרים אזור ותחום למכונה שתואמים לתחום שבחרתם כשיצרתם את האשכול. לדוגמה, אם השתמשתם ב-us-central1-a בשביל COMPUTE_ZONE כשיצרתם את האשכול, במסך יצירת המופע בוחרים ב-us-central1 (Iowa) בשביל אזור וב-us-central1-a בשביל אזור.

  4. בקטע Boot disk לוחצים על Change כדי להתחיל בהגדרת דיסק האתחול.

  5. בכרטיסייה תמונות ציבוריות, בוחרים בגרסה 9 של מערכת ההפעלה Debian.

  6. לוחצים על בחירה.

  7. בקטע Identity and API access (זהות וגישה ל-API), בוחרים את חשבון השירות שיצרתם.

  8. בקטע Firewall, בוחרים באפשרות Allow HTTP traffic.

  9. לוחצים על יצירה כדי ליצור את המופע.

gcloud

כדי ליצור מכונת חישוב, מריצים את ה-method‏ gcloud compute instances create עם האפשרויות הבאות:

  • ה-ZONE שבחרתם כשיצרתם את האשכול
  • התג http-server כדי לאפשר תנועת HTTP
  • ה-SERVICE_ACCOUNT שיצרתם
gcloud compute instances create COMPUTE_NAME \
   --project=PROJECT_ID \
   --zone=ZONE \
   --image-family=debian-10 \
   --image-project=debian-cloud \
   --tags=http-server \
   --service-account=SERVICE_ACCOUNT

הפלט אמור להיראות כך:

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/COMPUTE_NAME].
NAME          ZONE           MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP    STATUS
COMPUTE_NAME  ZONE           n1-standard-1               INTERNAL_IP  EXTERNAL_IP    RUNNING

צריך להמתין זמן קצר עד שהמופע יופעל. אחרי שהמופע יופעל, הוא יופיע ברשימה בדף המכונות הווירטואליות עם סמל סטטוס ירוק.

כברירת מחדל, המופע משתמש באותה רשת VPC שמוגדרת כברירת מחדל שבה משתמשת האשכול, מה שאומר שאפשר לשלוח תעבורת נתונים מהמופע לאשכול.

כדי להתחבר למופע, מבצעים את השלבים הבאים:

המסוף

  1. נכנסים לדף VM Instances במסוף Google Cloud .

    כניסה לדף VM Instances

  2. ברשימת המכונות הווירטואליות, לוחצים על SSH בשורה של המכונה שיצרתם.

gcloud

כדי להתחבר למכונה, מריצים את הפקודה gcloud compute ssh:

gcloud compute ssh INSTANCE_NAME \
    --project PROJECT_ID \
    --zone ZONE

עכשיו יש לכם חלון טרמינל שדרכו אפשר לתקשר עם מופע Linux.

  1. בחלון הטרמינל, מתקינים את Netcat:

    sudo apt install netcat

  2. מורידים את הקובץ hl7v2-mllp-sample.txt ושומרים אותו במופע. למידע על הקידוד ועל התווים שמסיימים את הפלחים שמשמשים בקובץ, אפשר לעיין במאמר בנושא מפרידי פלחים וקידוד של הודעות HL7v2.

  3. כדי להתחיל לשלוח הודעות HL7v2 דרך מתאם MLLP אל מאגר HL7v2, מריצים את הפקודה הבאה בספרייה שבה הורדתם את הקובץ. משתמשים בערך של LoadBalancer Ingress שהוצג כשבדקתם את השירות.

    echo -n -e "\x0b$(cat hl7v2-mllp-sample.txt)\x1c\x0d" | nc LOAD_BALANCER_INGRESS_IP_ADDRESS 2575

    אחרי הרצת הפקודה, ההודעה נשלחת דרך מתאם MLLP אל מאגר HL7v2. אם ההודעה נקלטה בהצלחה במאגר HL7v2, הפקודה תחזיר את הפלט הבא:

    MSA|AA|20150503223000|ILITY|FROM_APP|FROM_FACILITY|20190312162410||ACK|f4c59243-19c2-4373-bea0-39c1b2ba616b|P|2.5

    הפלט הזה מציין שהמאגר של HL7v2 הגיב עם סוג תגובה AA (Application Accept), כלומר ההודעה אומתה והוכנסה בהצלחה.

  4. כדי לראות את ההודעה שפורסמה בנושא Pub/Sub, מריצים את הפקודה gcloud pubsub subscriptions pull:

    gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION

    הפקודה מחזירה את הפלט הבא לגבי הודעת HL7v2 שהוטמעה:

    ┌-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┐
|                                                               DATA                                              |    MESSAGE_ID   |   ATTRIBUTES  |
├-----------------------------------------------------------------------------------------------------------------|-----------------|---------------|
| projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/HL7V2_MESSAGE_ID | 123456789012345 | msgType=ADT   |
└-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘

  5. אפשר גם להציג רשימה של ההודעות במאגר HL7v2 כדי לראות אם ההודעה נוספה:

    curl

    curl -X GET \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages"

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

    {
  "hl7V2Messages": [
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID"
    }
  ]
}

    PowerShell

    $cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Get `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages" | Select-Object -Expand Content

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

    {
  "hl7V2Messages": [
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID"
    }
  ]
}

אחרי שתשלימו את השלב הזה, תסיימו בהצלחה את הפריסה של מתאם MLLP ב-GKE ותשלחו הודעת HL7v2 ממופע מרוחק דרך המתאם אל Cloud Healthcare API.

בהמשך המדריך הזה תלמדו איך להצפין בצורה מאובטחת את ההודעות של HL7v2 שמועברות, על ידי הגדרת VPN בין מכונת Compute Engine, שפועלת כמכונה 'במקום', לבין המתאם.

הגדרת VPN

שימוש ב-VPN מאפשר לכם להרחיב את הרשת הפרטית שבה אתם שולחים הודעות HL7v2 לרשת ציבורית, כמו האינטרנט. כשמשתמשים ב-VPN, אפשר לשלוח הודעות ממרכז הטיפול דרך מתאם MLLP אלGoogle Cloud. המערכות בתרשים הזה פועלות כאילו הן נמצאות ברשת פרטית אחת.

יש שתי שיטות לאבטחת חיבור MLLP באמצעות VPN:

הגדרת Cloud VPN

שירות Cloud VPN מחבר באופן מאובטח את הרשת המקומית שלכם לרשתGoogle Cloud הענן הווירטואלי הפרטי (VPC) באמצעות חיבור IPsec VPN. התנועה בין שתי הרשתות מוצפנת על ידי שער VPN אחד, ואז מפוענחת על ידי שער ה-VPN השני. כך הנתונים שלכם מוגנים בזמן שהם מועברים באינטרנט או ברשת של מרכז טיפול.

במדריך הזה, כל שער VPN שתגדירו ממוקם ברשת מותאמת אישית אחרת ובתת-רשת באזור אחר. Google Cloud

שער ה-VPN שהוגדר ב-us-central1 פועל כשער Cloud VPN בצד Google Cloud , ושער Cloud VPN ב-europe-west1 מדמה את השער 'המקומי'.

הפניה לשמות וכתובות

לצורך ההפניה, במדריך הזה נעשה שימוש בשמות ובכתובות ה-IP הבאים:

Google Cloud side

  • שם הרשת: cloud-vpn-network
  • שם תת-הרשת: subnet-us-central-10-0-1
  • אזור: us-central1
  • טווח תת-הרשת: 10.0.1.0/24
  • שם כתובת ה-IP החיצונית: cloud-vpn-ip
  • שם שער ה-VPN: ‏ vpn-us-central
  • שם מנהרת ה-VPN: ‏ vpn-us-central-tunnel-1

הצד של "התקנה מקומית"

  • שם הרשת: on-prem-vpn-network
  • שם תת-הרשת: subnet-europe-west-10-0-2
  • אזור: europe-west1
  • טווח תת-הרשת: 10.0.2.0/24
  • שם כתובת ה-IP החיצונית: on-prem-vpn-ip
  • שם שער ה-VPN: ‏ vpn-europe-west
  • שם מנהרת ה-VPN: ‏ vpn-europe-west-tunnel-1

יצירת רשתות ותת-רשתות מותאמות אישית של VPC

השלב הראשון בהגדרת Cloud VPN הוא יצירת שתי רשתות VPC. רשת אחת, שנקראת on-prem-vpn-network, מוגדרת בסביבה 'המקומית' ופועלת במכונה וירטואלית של Compute Engine שנקראת on-prem-instance. הרשת השנייה, שנקראת cloud-vpn-network, היא הרשת שבה משתמש אשכול GKE שמריץ את מתאם MLLP. תתחברו למכונה הווירטואלית on-prem-instance ותשלחו הודעות HL7v2 למתאם MLLP שפועל ברשת cloud-vpn-network דרך מאזן העומסים הפנימי של מתאם MLLP.

כדי ליצור שתי רשתות VPC מותאמות אישית ואת רשתות המשנה שלהן, מבצעים את השלבים הבאים:

  1. כדי ליצור את רשת ה-VPC הראשונה, cloud-vpn-network, מריצים את הפקודה הבאה:

    gcloud compute networks create cloud-vpn-network \
   --project=PROJECT_ID \
   --subnet-mode=custom

  2. כדי ליצור את רשת המשנה subnet-us-central-10-0-1 עבור הרשת cloud-vpn-network מריצים את הפקודה הבאה:

    gcloud compute networks subnets create subnet-us-central-10-0-1 \
   --project=PROJECT_ID \
   --region=us-central1 \
   --network=cloud-vpn-network \
   --range=10.0.1.0/24

  3. כדי ליצור את רשת ה-VPC‏ on-prem-vpn-network, מריצים את הפקודה הבאה:

    gcloud compute networks create on-prem-vpn-network \
   --project=PROJECT_ID \
   --subnet-mode=custom

  4. כדי ליצור את רשת המשנה subnet-europe-west-10-0-2 עבור רשת ה-VPC‏ on-prem-vpn-network, מריצים את הפקודה הבאה:

    gcloud compute networks subnets create subnet-europe-west-10-0-2 \
   --project=PROJECT_ID \
   --region=europe-west1 \
   --network=on-prem-vpn-network \
   --range=10.0.2.0/24

יצירת כתובת IP חיצונית

לפני שיוצרים שערי VPN, צריך להזמין כתובת IP חיצונית לכל שער. לשם כך, מבצעים את השלבים הבאים:

  1. כדי לשמור כתובת IP חיצונית אזורית (סטטית) בשביל cloud-vpn-ip הכתובת, מריצים את הפקודה הבאה:

    gcloud compute addresses create cloud-vpn-ip \
   --project=PROJECT_ID \
   --region=us-central1

  2. כדי לשמור כתובת IP חיצונית אזורית (סטטית) בשביל on-prem-vpn-ip הכתובת, מריצים את הפקודה הבאה:

    gcloud compute addresses create on-prem-vpn-ip \
   --project=PROJECT_ID \
   --region=europe-west1

  3. חשוב לשים לב לכתובות ה-IP החיצוניות כדי שתוכלו להשתמש בהן להגדרת שערים של VPN בקטע הבא. כדי לאחזר את כתובות ה-IP החיצוניות, מריצים את הפקודה הבאה:

    כתובת ה-IP של Cloud VPN:

    gcloud compute addresses describe cloud-vpn-ip  \
   --project PROJECT_ID \
   --region us-central1 \
   --format='flattened(address)'

    כתובת ה-IP של ה-VPN 'במקום':

    gcloud compute addresses describe on-prem-vpn-ip \
   --project PROJECT_ID \
   --region europe-west1 \
   --format='flattened(address)'

    הפקודות מחזירות פלט שדומה לזה:

    address: 203.0.113.1

יצירת שערי VPN, מנהרות ומסלולים

כדי ליצור את שער ה-VPN, המנהרה והמסלול ל-Cloud VPN:

  1. יוצרים מפתח ששותף מראש (סוד לשימוש עם טוקן צרכן) חזק מבחינה קריפטוגרפית לפי ההוראות במאמר יצירת מפתח משותף מראש חזק. המפתח הזה נקרא SHARED_SECRET בקטע הזה.

  2. כדי ליצור את אובייקט שער ה-VPN ליעד, מריצים את הפקודה הבאה:

    gcloud compute target-vpn-gateways create vpn-us-central \
   --project PROJECT_ID \
   --region us-central1 \
   --network cloud-vpn-network

  3. כדי ליצור שלושה כללי העברה, מריצים את הפקודות הבאות ומחליפים את המשתנה CLOUD_VPN_EXTERNAL_ADDRESS בערך מכתובת ה-IP של Cloud VPN בקטע הקודם:

    שליחת תעבורת ESP ‏ (IPsec) לשער:

    gcloud compute forwarding-rules create vpn-us-central-rule-esp \
    --project PROJECT_ID \
    --region us-central1 \
    --address CLOUD_VPN_EXTERNAL_ADDRESS \
    --ip-protocol ESP \
    --target-vpn-gateway vpn-us-central

    שליחת תעבורת UDP 500 לשער:

    gcloud compute forwarding-rules create vpn-us-central-rule-udp500 \
    --project PROJECT_ID \
    --region us-central1 \
    --address CLOUD_VPN_EXTERNAL_ADDRESS \
    --ip-protocol UDP \
    --ports 500 \
    --target-vpn-gateway vpn-us-central

    שליחת תנועת UDP 4500 לשער:

    gcloud compute forwarding-rules create vpn-us-central-rule-udp4500 \
    --project PROJECT_ID \
    --region us-central1 \
    --address CLOUD_VPN_EXTERNAL_ADDRESS \
    --ip-protocol UDP \
    --ports 4500 \
    --target-vpn-gateway vpn-us-central

  4. כדי ליצור מנהרה לשער Cloud VPN, מריצים את הפקודה הבאה. מחליפים את ON_PREM_VPN_IP בערך מכתובת ה-IP של ה-VPN On-premises בקטע הקודם.

    gcloud compute vpn-tunnels create vpn-us-central-tunnel-1 \
    --project PROJECT_ID \
    --region us-central1 \
    --peer-address ON_PREM_VPN_IP \
    --shared-secret SHARED_SECRET \
    --ike-version 2 \
    --local-traffic-selector 0.0.0.0/0 \
    --target-vpn-gateway vpn-us-central

  5. כדי ליצור נתיב סטטי אל 10.0.2.0/24, מריצים את הפקודה הבאה:

    gcloud compute routes create "vpn-us-central-tunnel-1-route-1" \
   --project PROJECT_ID \
   --network "cloud-vpn-network" \
   --next-hop-vpn-tunnel "vpn-us-central-tunnel-1" \
   --next-hop-vpn-tunnel-region "us-central1" \
   --destination-range "10.0.2.0/24"

כדי ליצור את שער ה-VPN, המנהרה והמסלול ל-VPN 'on-premises':

  1. כדי ליצור את אובייקט שער ה-VPN ליעד, מריצים את הפקודה הבאה:

    gcloud compute target-vpn-gateways create "vpn-europe-west" \
   --project PROJECT_ID \
   --region "europe-west1" \
   --network "on-prem-vpn-network"

  2. כדי ליצור שלושה כללי העברה, מריצים את הפקודות הבאות ומחליפים את המשתנה ON_PREMISES_VPN_EXTERNAL_ADDRESS בערך מכתובת ה-IP של ה-VPN 'במקום' בקטע הקודם:

    שליחת תעבורת ESP ‏ (IPsec) לשער:

    gcloud compute forwarding-rules create vpn-europe-west-rule-esp \
    --project PROJECT_ID \
    --region europe-west1 \
    --address ON_PREMISES_VPN_EXTERNAL_ADDRESS \
    --ip-protocol ESP \
    --target-vpn-gateway vpn-europe-west

    שליחת תעבורת UDP 500 לשער:

    gcloud compute forwarding-rules create vpn-europe-west-rule-udp500 \
    --project PROJECT_ID \
    --region europe-west1 \
    --address ON_PREMISES_VPN_EXTERNAL_ADDRESS \
    --ip-protocol UDP \
    --ports 500 \
    --target-vpn-gateway vpn-europe-west

    שליחת תנועת UDP 4500 לשער:

    gcloud compute forwarding-rules create vpn-europe-west-rule-udp4500 \
     --project PROJECT_ID \
     --region europe-west1 \
     --address ON_PREMISES_VPN_EXTERNAL_ADDRESS \
     --ip-protocol UDP \
     --ports 4500 \
     --target-vpn-gateway vpn-europe-west

  3. כדי ליצור מנהרה לשער 'on-premises', מריצים את הפקודה הבאה:

    gcloud compute vpn-tunnels create vpn-europe-west-tunnel-1 \
   --project PROJECT_ID \
   --region europe-west1 \
   --peer-address CLOUD_VPN_IP \
   --shared-secret SHARED_SECRET \
   --ike-version 2 \
   --local-traffic-selector 0.0.0.0/0 \
   --target-vpn-gateway vpn-europe-west

  4. כדי ליצור נתיב סטטי אל 10.0.1.0/24, מריצים את הפקודה הבאה:

    gcloud compute routes create "vpn-europe-west-tunnel-1-route-1" \
   --project PROJECT_ID \
   --network "on-prem-vpn-network" \
   --next-hop-vpn-tunnel "vpn-europe-west-tunnel-1" \
   --next-hop-vpn-tunnel-region "europe-west1" \
   --destination-range "10.0.1.0/24"

יצרתם את שערי Cloud VPN ו-VPN מקומי והפעלתם את המנהרות שלהם. שערי ה-VPN לא יתחברו עד שתיצרו כללים של חומת אש שיאפשרו תעבורת נתונים דרך המנהרה ביניהם.

יצירת כללים לחומת האש

צריך ליצור כללים של חומת אש לשני הצדדים של מנהרת ה-VPN. הכללים האלה מאפשרים לכל תעבורת ה-TCP,‏ UDP ו-ICMP להיכנס מרשת המשנה בצד אחד של מנהרת ה-VPN לצד השני.

  1. כדי ליצור את כללי חומת האש לתת-הרשת של Cloud VPN, מריצים את הפקודה הבאה:

    gcloud compute firewall-rules create allow-tcp-udp-icmp-cloud-vpn \
   --project=PROJECT_ID \
   --direction=INGRESS \
   --priority=1000 \
   --network=cloud-vpn-network \
   --action=ALLOW \
   --rules=tcp,udp,icmp \
   --source-ranges=10.0.2.0/24

  2. כדי ליצור את הכללים של חומת האש עבור רשת המשנה 'on-premises', מריצים את הפקודה הבאה:

    gcloud compute firewall-rules create allow-tcp-udp-icmp-on-prem-vpn \
   --project=PROJECT_ID \
   --direction=INGRESS \
   --priority=1000 \
   --network=on-prem-vpn-network \
   --action=ALLOW \
   --rules=tcp,udp,icmp \
   --source-ranges=10.0.1.0/24

  3. יוצרים כלל חומת אש שמאפשר להתחבר למכונה הווירטואלית באמצעות SSH ביציאה 22 על ידי הרצת הפקודה הבאה:

    gcloud compute firewall-rules create on-prem-vpn-allow-ssh \
   --project=PROJECT_ID \
   --direction=INGRESS \
   --priority=1000 \
   --network=on-prem-vpn-network \
   --action=ALLOW \
   --rules=tcp:22 \
   --source-ranges=0.0.0.0/0

בדיקת הסטטוס של מנהרת ה-VPN

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

  1. עוברים לדף VPN במסוף Google Cloud .

    מעבר לדף VPN

  2. לוחצים על הכרטיסייה Google VPN Tunnels (מנהרות VPN של Google).

  3. בשדה סטטוס של כל מנהרה, מחפשים סימן וי ירוק ואת המילה Established (נוצר). אם הפריטים האלה מופיעים, המשמעות היא שהשערים ניהלו משא ומתן על מנהרה. אם הסימן לא מופיע אחרי כמה דקות, אפשר לעיין בקטע פתרון בעיות.

    מידע נוסף על רישום ביומנים שקשור למנהרות ה-VPN זמין במאמר בדיקת יומני VPN בדף פתרון הבעיות. לדוגמה, אתם יכולים לראות מדדים לגבי מנות שהושמטו, סטטוס המנהור, בייטים שהתקבלו ובייטים שנשלחו.

אחרי שהגדרתם בהצלחה את Cloud VPN עם השערים, המנהרות וכללי חומת האש הנדרשים, אתם יכולים ליצור חיבור מאובטח בין מופע ה-VM 'המקומי' לבין מתאם ה-MLLP שפועל ב-GKE.

שילוב פריסה ב-GKE וב-Cloud VPN

בשלב מוקדם יותר במדריך הזה בדקתם את מתאם MLLP באופן מקומי ושלחתם הודעות HL7v2 דרך חיבור שלא מבוסס על VPN למתאם MLLP. עכשיו תשלחו הודעות ממכונה וירטואלית של Compute Engine דרך חיבור מאובטח באמצעות Cloud VPN למתאם MLLP שפועל ב-GKE. ההודעות מועברות לחנות HL7v2.

יצירה מחדש של הפריסה

קודם צריך ליצור מחדש את הפריסה ב-GKE כדי שהאשכול ישתמש בהגדרות שהגדרתם בהגדרת Cloud VPN:

  1. כדי למחוק את אשכול mllp-adapter שיצרתם, מריצים את הפקודה gcloud container clusters delete. מזינים את הערך COMPUTE_ZONE שבו השתמשתם כשיצרתם את האשכול.

    gcloud container clusters delete mllp-adapter --zone=COMPUTE_ZONE

  2. פועלים לפי השלבים במאמר פריסת מתאם MLLP ב-Kubernetes Engine, אבל כשיוצרים את האשכול ב-GKE, מוסיפים את רשת cloud-vpn-network ואת תת-הרשת subnet-us-central-10-0-1 שיצרתם במאמר יצירת רשתות ותת-רשתות VPN בהתאמה אישית.

    מוודאים שפקודת יצירת האשכול נראית כך:

    gcloud container clusters create mllp-adapter \
   --zone=COMPUTE_ZONE \
   --service-account=CLIENT_EMAIL \
   --network=cloud-vpn-network \
   --subnetwork=subnet-us-central-10-0-1

    where:

    • ‫COMPUTE_ZONE הוא האזור שבו האשכול נפרס. כשמגדירים את Cloud VPN בקטע הקודם, מגדירים את הרשת בצדGoogle Cloud לשימוש ב-us-central1. הרשת הזו, 'Google Cloud side', היא הרשת שבה פועל אשכול GKE. אפשר להשתמש באחד מהאזורים הבאים ב-us-central1: us-central1-c,‏ us-central1-a, ‏ us-central1-f, ‏ us-central1-b.

      Google Cloud

    • ‫CLIENT_EMAIL הוא המזהה של חשבון השירות שבו רוצים להשתמש. הפורמט הוא SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.

יצירת מכונה וירטואלית חדשה ב-Compute Engine עם הגדרות רשת

בשלבים הבאים מוסבר איך ליצור מכונה וירטואלית של Linux ב-Compute Engine באמצעות מסוף Google Cloud . בניגוד למכונה וירטואלית ב-Compute Engine שיצרתם, המכונה הווירטואלית הזו משתמשת בהגדרות הרשת של 'הצד המקומי' כדי לתקשר עם אשכול GKE באמצעות VPN.

המסוף

  1. נכנסים לדף VM Instances במסוף Google Cloud .

    כניסה לדף VM Instances

  2. לוחצים על Create instance.

  3. בוחרים Region ו-Zone למכונה שתואמת להגדרות הרשת של "הצד המקומי": europe-west1 (Belgium) בשדה Region ו-europe-west1-b בשדה Zone.

  4. בקטע Boot disk לוחצים על Change כדי להתחיל בהגדרת דיסק האתחול.

  5. בכרטיסייה תמונות ציבוריות, בוחרים בגרסה 9 של מערכת ההפעלה Debian.

  6. לוחצים על בחירה.

  7. בקטע Identity and API access בוחרים את חשבון השירות שיצרתם.

  8. בקטע Firewall, בוחרים באפשרות Allow HTTP traffic.

  9. מרחיבים את הקטע Management, security, disks, networking, sole tenancy.

  10. בקטע Network interfaces בכרטיסייה Networking, מציינים את פרטי הרשת של הגדרות הרשת "בצד 'המקומי'":

    1. בשדה Network בוחרים באפשרות on-prem-vpn-network.
    2. בשדה Subnetwork, בוחרים באפשרות subnet-europe-west-10-0-2 (10.0.2.0/24).

  11. לוחצים על יצירה כדי ליצור את המופע.

צריך להמתין זמן קצר עד שהמופע יופעל. כשהיא מוכנה, היא מופיעה ברשימה בדף המכונות הווירטואליות עם סמל סטטוס ירוק.

gcloud

כדי ליצור מכונת חישוב, מריצים את ה-method‏ gcloud compute instances create עם האפשרויות הבאות:

  • ה-ZONE שמתאים להגדרות הרשת של "הצד המקומי": europe-west1-b בשביל האזור.
  • מאפשרים תנועה מסוג HTTP על ידי ציון התג http-server
  • ה-SERVICE_ACCOUNT שיצרתם
gcloud compute instances create COMPUTE_NAME \
   --project=PROJECT_ID
   --zone=ZONE
   --image-family=debian-10 \
   --tags=http-server,https-server
   --service-account=SERVICE_ACCOUNT

הפלט אמור להיראות כך:

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/COMPUTE_NAME].
NAME          ZONE           MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP    STATUS
COMPUTE_NAME  ZONE           n1-standard-1               INTERNAL_IP  EXTERNAL_IP    RUNNING

כדי להתחבר למופע, מבצעים את השלבים הבאים:

המסוף

  1. נכנסים לדף VM Instances במסוף Google Cloud .

    כניסה לדף VM Instances

  2. ברשימת המכונות הווירטואליות, לוחצים על SSH בשורה של המכונה שיצרתם.

gcloud

כדי להתחבר למכונה, מריצים את הפקודה gcloud compute ssh:

gcloud compute ssh INSTANCE_NAME \
    --project PROJECT_ID \
    --zone ZONE

עכשיו יש לכם חלון טרמינל שדרכו אפשר לתקשר עם מופע Linux.

  1. בחלון הטרמינל, מתקינים את Netcat:

    sudo apt install netcat

  2. מורידים את הקובץ hl7v2-mllp-sample.txt ושומרים אותו במופע.

  3. כדי להתחיל לשלוח הודעות HL7v2 דרך מתאם MLLP אל מאגר HL7v2, מריצים את הפקודה הבאה בספרייה שבה הורדתם את הקובץ. משתמשים בערך של LoadBalancer Ingress שהוצג כשבדקתם את השירות.

    echo -n -e "\x0b$(cat hl7v2-mllp-sample.txt)\x1c\x0d" | nc LOAD_BALANCER_INGRESS_IP_ADDRESS 2575

    אחרי הרצת הפקודה, ההודעה נשלחת דרך מתאם MLLP אל מאגר HL7v2. אם ההודעה נקלטה בהצלחה במאגר HL7v2, הפקודה תחזיר את הפלט הבא:

    MSA|AA|20150503223000|ILITY|FROM_APP|FROM_FACILITY|20190312162410||ACK|f4c59243-19c2-4373-bea0-39c1b2ba616b|P|2.5

    הפלט הזה מציין שהתגובה של מאגר HL7v2 היא מסוג AA (Application Accept), כלומר ההודעה אומתה והוכנסה בהצלחה.

  4. כדי לראות את ההודעה שפורסמה בנושא ב-Pub/Sub, מריצים את הפקודה gcloud pubsub subscriptions pull:

    gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION

    הפקודה מחזירה את הפלט הבא לגבי הודעת HL7v2 שהוטמעה:

    ┌-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┐
|                                                               DATA                                              |    MESSAGE_ID   |   ATTRIBUTES  |
├-----------------------------------------------------------------------------------------------------------------|-----------------|---------------|
| projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/HL7V2_MESSAGE_ID | 123456789012345 | msgType=ADT   |
└-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘

  5. אפשר גם להציג רשימה של ההודעות במאגר HL7v2 כדי לראות אם ההודעה נוספה:

    curl

    curl -X GET \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages"

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

    {
  "hl7V2Messages": [
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID"
    }
  ]
}

    PowerShell

    $cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Get `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages" | Select-Object -Expand Content

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

    {
  "hl7V2Messages": [
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID"
    }
  ]
}

אחרי שתשלימו את השלב הזה, תסיימו בהצלחה את פריסת מתאם MLLP ב-GKE, ותשלחו בצורה מאובטחת דרך VPN הודעת HL7v2 ממופע 'במקום' דרך המתאם אל Cloud Healthcare API.

הסרת המשאבים

כדי להימנע מחיובים בחשבון Google Cloud על המשאבים שבהם השתמשתם במדריך הזה, אתם יכולים למחוק את המשאבים שיצרתם ב-Google Cloud.

מחיקת הפרויקט

כדי למחוק את הפרויקט שיצרתם במדריך הזה:

  1. במסוף Google Cloud , נכנסים לדף Manage resources.

    כניסה לדף Manage resources

  2. ברשימת הפרויקטים, בוחרים את הפרויקט שרוצים למחוק ולוחצים על Delete.
  3. כדי למחוק את הפרויקט, כותבים את מזהה הפרויקט בתיבת הדו-שיח ולוחצים על Shut down.

פתרון בעיות

כשלים במתאם

אחרי פריסת המתאם MLLP ב-GKE, המתאם נתקל בכשל.

שגיאת Connection refused בהרצה מקומית

כשבודקים את מתאם MLLP באופן מקומי, מוצגת השגיאה Connection refused.

  • השגיאה הזו מתרחשת אצל חלק מהמשתמשים ב-Mac OS. במקום להשתמש בדגל --network=host, משתמשים ב--p 2575:2575. בנוסף, במקום להגדיר את הערך --receiver_ip=127.0.0.0, מגדירים את הערך --receiver_ip=0.0.0.0. הפקודה צריכה להיראות כך:

    docker run \
  -p 2575:2575 \
  gcr.io/cloud-healthcare-containers/mllp-adapter \
  /usr/mllp_adapter/mllp_adapter \
  --hl7_v2_project_id=PROJECT_ID \
  --hl7_v2_location_id=LOCATION \
  --hl7_v2_dataset_id=DATASET_ID \
  --hl7_v2_store_id=HL7V2_STORE_ID \
  --export_stats=false \
  --receiver_ip=0.0.0.0 \
  --pubsub_project_id=PROJECT_ID \
  --pubsub_subscription=PUBSUB_SUBSCRIPTION \
  --api_addr_prefix=https://healthcare.googleapis.com:443/v1 \
  --logtostderr

שגיאת could not find default credentials בהרצה מקומית

כשבודקים את מתאם MLLP באופן מקומי, מוצגת השגיאה healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials..

השגיאה הזו מתרחשת כשהמתאם לא מצליח למצוא את פרטי הכניסה המקומיים שלכם ל-ADC. מוודאים שהגדרתם Application Default Credentials בסביבה המקומית.

שגיאות אימות

אם נתקלתם בשגיאות אימות כשבדקתם את מתאם MLLP באופן מקומי ואין הסבר לשגיאות האלה בהמשך הקטע הזה, הפעילו מחדש את הפקודה docker run והוסיפו את הדגל -v ~/.config:/root/.config לסוף הפקודה, באופן הבא:

docker run \
-v ~/.config:/root/.config \
...