Diese Seite wurde von der Cloud Translation API übersetzt.

HL7v2-Nachrichten über TCP/IP-Verbindungen senden

Diese Anleitung enthält Anweisungen zum Übertragen von HL7v2-Nachrichten über TCP/IP-Verbindungen mit dem minimalen Low-Layer-Protokoll (MLLP). Wenn Sie möchten, dass das MLLP-Image von einem Attestierer signiert wird, führen Sie die Schritte unter HL7v2-Nachrichten über TCP/IP-Verbindungen mit einem signierten MLLP-Image übertragen aus.

In dieser Anleitung wird beschrieben, wie Sie den in GitHub gehosteten Open-Source-MLLP-Adapter in den folgenden Umgebungen ausführen:

Lokal/lokal
In einem Container in GKE mit Cloud VPN
In einem Container in GKE ohne Cloud VPN.

Ziele

Nach Abschluss dieser Anleitung beherrschen Sie Folgendes:

Erstellen und konfigurieren Sie den MLLP-Adapter lokal mit der Cloud Healthcare API und testen Sie das Senden von HL7v2-Nachrichten an einen HL7v2-Speicher.
MLLP-Adapter in GKE bereitstellen und HL7v2-Nachrichten von einer Compute Engine-VM-Instanz senden.
Konfigurieren Sie ein VPN, das die Verbindung zwischen einer lokalen Instanz und dem MLLP-Adapter sichert, und senden Sie HL7v2-Nachrichten von der lokalen Instanz.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

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

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Hinweise

Bevor Sie mit dieser Anleitung beginnen, sollten Sie sich mit der MLLP und dem Google Cloud MLLP-Adapter vertraut machen. Die Konzeptdokumentation bietet einen Überblick über MLLP, wie Pflegesysteme Nachrichten über eine MLLP-Verbindung an die Cloud Healthcare API senden und von ihr empfangen können, sowie die Grundlagen der MLLP-Sicherheit.

Bevor Sie den MLLP-Adapter einrichten können, müssen Sie ein Google Cloud-Projekt auswählen oder erstellen und die erforderlichen APIs wie folgt aktivieren:

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud Healthcare API, Google Kubernetes Engine, Container Registry, and Pub/Sub APIs.

Enable the APIs

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud Healthcare API, Google Kubernetes Engine, Container Registry, and Pub/Sub APIs.

Enable the APIs

Warten Sie, bis die Kubernetes Engine API und die zugehörigen Dienste aktiviert sind. Dieser Vorgang kann einige Minuten dauern.

Shell auswählen

Für diese Anleitung können Sie Cloud Shell oder Ihre lokale Shell verwenden.

Cloud Shell ist eine Shell-Umgebung für die Verwaltung von Ressourcen, die in Google Cloud gehostet werden. In Cloud Shell sind die gcloud CLI und das Tool kubectl vorinstalliert. Die gcloud CLI bietet die primäre Befehlszeile für Google Cloud. kubectl bietet die Befehlszeile zum Ausführen von Befehlen für GKE-Cluster.

Wenn Sie Ihre lokale Shell bevorzugen, müssen Sie die gcloud CLI installieren.

So öffnen Sie Cloud Shell oder konfigurieren Ihre lokale Shell:

Cloud Shell

So starten Sie Cloud Shell:

Rufen Sie die Google Cloud Console auf.

Google Cloud Console
Klicken Sie in der oberen rechten Ecke der Console auf die Schaltfläche Google Cloud Shell aktivieren:

Im unteren Bereich der Konsole wird ein Frame für die Cloud Shell-Sitzung geöffnet. In dieser Shell führen Sie gcloud- und kubectl-Befehle aus.

Lokale Shell

So installieren Sie die gcloud CLI und das kubectl-Tool:

Installieren und initialisieren Sie das Google Cloud CLI.
If you're using a local shell, then create local authentication credentials for your user account:
```
gcloud auth application-default login
```
You don't need to do this if you're using Cloud Shell.
Wenn Sie den Adapter nur lokal testen, müssen Sie keine weiteren Schritte ausführen und können mit Dataset erstellen fortfahren. Wenn Sie den Adapter in GKE bereitstellen, installieren Sie das kubectl-Befehlszeilentool mit dem folgenden Befehl:
```
gcloud components install kubectl
```

Dataset erstellen

Wenn Sie noch kein Cloud Healthcare API-Dataset erstellt haben, erstellen Sie ein Dataset, indem Sie die folgenden Schritte ausführen:

Console

Öffnen Sie in der Google Cloud Console die Seite Datasets.
Zu „Datasets“
Klicken Sie auf Dataset erstellen.
Geben Sie im Feld Name eine Kennzeichnung für das Dataset ein. Die Dataset-ID muss Folgendes enthalten:
- Eine eindeutige ID an ihrem Standort
- Ein Unicode-String mit 1 bis 256 Zeichen, der Folgendes umfasst:
  - Nummern
  - Buchstaben
  - Unterstriche
  - Bindestriche
  - Punkte
Wählen Sie im Bereich Standorttyp einen der folgenden Standorttypen aus:
- Region: Das Dataset befindet sich dauerhaft in einer Google Cloud-Region. Nachdem Sie die Option ausgewählt haben, geben Sie sie in das Feld Region ein oder wählen Sie sie aus.
- Multiregional: Das Dataset befindet sich dauerhaft an einem Standort, der mehrere Google Cloud-Regionen umfasst. Geben Sie nach der Auswahl den multiregionalen Standort im Feld „Mehrere Regionen” ein oder wählen Sie ihn aus.
Klicken Sie auf Erstellen.

Das neue Dataset wird in der Liste der Datasets angezeigt.

gcloud

Führen Sie den Befehl gcloud healthcare datasets create aus, um ein Dataset zu erstellen:

gcloud healthcare datasets create DATASET_ID \
    --location=LOCATION

Wenn die Anfrage erfolgreich ist, gibt der Befehl die folgende Ausgabe zurück:

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

Pub/Sub-Thema und -Abo erstellen

Um Benachrichtigungen zu erhalten, wenn Nachrichten erstellt oder aufgenommen werden, müssen Sie ein Pub/Sub-Thema mit Ihrem HL7v2-Speicher konfigurieren. Weitere Informationen finden Sie unter Pub/Sub-Benachrichtigungen konfigurieren.

So erstellen Sie ein Thema:

Console

Rufen Sie in der Google Cloud Console die Seite Pub/Sub-Themen auf.

Zur Seite "Pub/Sub-Themen"
Klicken Sie auf Thema erstellen.
Geben Sie einen Themennamen mit folgendem URI ein:

projects/PROJECT_ID/topics/TOPIC_NAME

Dabei ist PROJECT_ID Ihre Google Cloud-Projekt-ID.
Klicken Sie auf Erstellen.

gcloud

Führen Sie den Befehl gcloud pubsub topics create aus, um ein Thema zu erstellen:

gcloud pubsub topics create projects/PROJECT_ID/topics/TOPIC_NAME

Wenn die Anfrage erfolgreich ist, gibt der Befehl die folgende Ausgabe zurück:

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

Um ein Abo zu erstellen, führen Sie die folgenden Schritte aus.

Console

Rufen Sie in der Google Cloud Console die Seite Pub/Sub-Themen auf.

Zur Seite "Pub/Sub-Themen"
Klicken Sie auf das Thema Ihres Projekts.
Klicken Sie auf Abo erstellen.
Geben Sie einen Namen für das Abo ein:

projects/PROJECT_ID/subscriptions/SUBSCRIPTION_NAME
Belassen Sie Auslieferungstyp auf Pull und klicken Sie auf Erstellen.

gcloud

Führen Sie den Befehl gcloud pubsub subscriptions create aus, um ein Abo zu erstellen:

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

Wenn die Anfrage erfolgreich ist, gibt der Befehl die folgende Ausgabe zurück:

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

Einen mit einem Pub/Sub-Thema konfigurierten HL7v2-Speicher erstellen

Erstellen Sie einen HL7v2-Speicher und konfigurieren Sie ihn mit einem Pub/Sub-Thema. Zum Erstellen eines HL7v2-Speichers müssen Sie bereits ein Dataset erstellt haben. Verwenden Sie für diese Anleitung dasselbe Projekt für Ihren HL7v2-Speicher und für das Pub/Sub-Thema.

So erstellen Sie einen mit einem Pub/Sub-Thema konfigurierten HL7v2-Speicher:

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"

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort im JSON-Format zurück:

{
  "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

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort im JSON-Format zurück:

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

Pub/Sub-Berechtigungen konfigurieren

Um Benachrichtigungen an Pub/Sub zu senden, wenn eine HL7v2-Nachricht erstellt oder aufgenommen wird, müssen Sie in der Cloud Healthcare API Pub/Sub-Berechtigungen konfigurieren. Dieser Schritt muss einmal pro Projekt durchgeführt werden.

So fügen Sie dem Dienstkonto Ihres Projekts die erforderliche Rolle pubsub.publisher hinzu:

Console

Prüfen Sie in der Google Cloud Console auf der Seite „IAM”, ob die Rolle Healthcare-Dienst-Agent in der Spalte Rolle für das entsprechende Projektdienstkonto angezeigt wird. Der Kontoname lautet service-PROJECT_NUMBER@gcp-sa-healthcare.iam.gserviceaccount.com. Informationen zum Suchen von PROJECT_NUMBER finden Sie unter Projekte identifizieren.
Klicken Sie in der Zeile mit der Rolle in der Spalte Übernahme auf das Bleistiftsymbol. Der Bereich Berechtigungen bearbeiten wird geöffnet.
Klicken Sie auf Weitere Rolle hinzufügen und suchen Sie nach der Rolle Pub/Sub-Publisher.
Wählen Sie die Rolle aus und klicken Sie auf Speichern. Die Rolle pubsub.publisher wird dem Dienstkonto hinzugefügt.

gcloud

Führen Sie den Befehl gcloud projects add-iam-policy-binding aus, um die Dienstkontoberechtigungen hinzuzufügen. Informationen zum Suchen von PROJECT_ID und PROJECT_NUMBER finden Sie unter Projekte identifizieren.

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

Das vordefinierte Docker-Image wird abgerufen.

Der MLLP-Adapter ist eine containerisierte Anwendung, die in einem vordefinierten Docker-Image in Container Registry bereitgestellt wird.

Führen Sie den folgenden Befehl aus, um die neueste Version des Images abzurufen:

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

MLLP-Adapter lokal testen

Wenn Sie den Adapter lokal testen, können Sie ihn so konfigurieren, dass er als Empfänger, Publisher oder beides ausgeführt wird. Die Konfiguration des Empfängers und des Publishers unterscheidet sich in folgenden Punkten:

Wenn der Adapter als Empfänger ausgeführt wird, empfängt er HL7v2-Nachrichten von einer externen Quelle und ruft messages.ingest auf, um die Nachrichten in einen HL7v2-Speicher aufzunehmen. Dadurch wird eine Pub/Sub-Benachrichtigung erstellt. Die Benachrichtigung wird an Anwendungen gesendet, die das Pub/Sub-Thema des HL7v2-Speichers abonniert haben.
Wenn der Adapter als Publisher ausgeführt wird, wartet er mit messages.create oder messages.ingest auf HL7v2-Nachrichten, die in einem HL7v2-Speicher erstellt oder aufgenommen wurden. Nachdem eine Nachricht erstellt wurde, wird eine Pub/Sub-Benachrichtigung an den Adapter gesendet und der Adapter veröffentlicht die Nachrichten an einen externen Empfänger.

In den folgenden Abschnitten wird gezeigt, wie Sie den Adapter ausführen, sodass er entweder als Empfänger oder als Publisher fungiert.

Nachdem Sie überprüft haben, ob Sie den MLLP-Adapter auf Ihrem lokalen Computer ausführen können, können Sie mit dem nächsten Abschnitt MLLP-Adapter in Google Kubernetes Engine bereitstellen fortfahren.

Den MLLP-Adapter lokal als Empfänger testen

Wenn der Adapter eine HL7v2-Nachricht von einer externen Quelle wie einem Pflegezentrum empfängt, ruft er messages.ingest auf und nimmt die HL7v2-Nachricht in den konfigurierten HL7v2-Speicher auf. Sie können dies im Quellcode für den Adapter beobachten.

So testen Sie den Adapter lokal als Empfänger:

Führen Sie auf dem Computer, auf dem Sie das vordefinierte Docker-Image abgerufen haben, den folgenden Befehl aus:
```
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
```
Dabei gilt:
- PROJECT_ID ist die ID für das Google Cloud-Projekt, das Ihren HL7v2-Speicher enthält.
- LOCATION ist die Region, in der sich Ihr HL7v2-Speicher befindet.
- DATASET_ID ist die ID für das übergeordnete Dataset Ihres HL7v2-Speichers.
- HL7V2_STORE_ID ist die ID des HL7v2-Speichers, an den Sie HL7v2-Nachrichten senden.
Nachdem Sie den vorherigen Befehl ausgeführt haben, gibt der Adapter eine Nachricht ähnlich der folgenden aus und wird auf Ihrem lokalen Computer unter der IP-Adresse 127.0.0.1 auf Port 2575 ausgeführt:
```
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.
```
Wenn Fehler auftreten, führen Sie die folgenden Schritte zur Fehlerbehebung aus:
- Wenn Sie Mac OS verwenden und der vorherige Befehl mit einem Connection refused-Fehler fehlschlägt, lesen Sie den Abschnitt Verbindung abgelehnt bei lokaler Ausführung.
- Wenn der vorherige Befehl mit dem Fehler healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials. See https://developers.google.com/accounts/docs/application-default-credentials for more information. fehlschlägt, lesen Sie den Abschnitt Fehler could not find default credentials bei lokaler Ausführung.
- Wenn andere Authentifizierungsfehler auftreten, lesen Sie den Hilfeartikel Authentifizierungsfehler.
Um mit dem Testen fortzufahren, während der Adapter als Vordergrundprozess ausgeführt wird, öffnen Sie ein anderes Terminal auf Ihrem lokalen Computer.
Führen Sie im neuen Terminal den folgenden Befehl aus, um Netcat zu installieren:
```
sudo apt install netcat
```
Laden Sie die Datei hl7v2-mllp-sample.txt herunter und speichern Sie sie auf Ihrem lokalen Computer.
Führen Sie den folgenden Befehl aus, um die HL7v2-Nachricht an den Adapter in dem Verzeichnis zu senden, in das Sie die Datei heruntergeladen haben. Der MLLP-Adapter überwacht Ihren lokalen Host auf Port 2575. Der Befehl sendet die Nachricht über den MLLP-Adapter an Ihren HL7v2-Speicher:
Linux
```
echo -n -e "\x0b$(cat hl7v2-mllp-sample.txt)\x1c\x0d" | nc -q1 localhost 2575 | less
```
Wenn die Nachricht erfolgreich in den HL7v2-Speicher aufgenommen wurde, gibt der Befehl die folgende Ausgabe zurück:
```
^KMSH|^~\&|TO_APP|TO_FACILITY|FROM_APP|FROM_FACILITY|19700101010000||ACK|c507a97e-438d-44b0-b236-ea95e5ecbbfb|P|2.5^MMSA|AA|20150503223000^\
```
Diese Ausgabe gibt an, dass der HL7v2-Speicher mit dem Antworttyp AA (Application Accept) geantwortet hat. Dies bedeutet, dass die Nachricht validiert und erfolgreich aufgenommen wurde.

Sie können auch überprüfen, ob die Nachricht erfolgreich gesendet wurde, indem Sie das Terminal öffnen, wo Sie den Adapter ausgeführt haben. Die Ausgabe sollte wie folgt aussehen:

 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.

Die Nachricht wird in Ihrem HL7v2-Speicher gespeichert, sodass Sie messages.list aufrufen können, um die Nachricht anzuzeigen:

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"

Wenn die Anfrage erfolgreich ist, gibt der Server die ID der Nachricht in einem Ressourcenpfad zurück:

{
  "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

Wenn die Anfrage erfolgreich ist, gibt der Server die ID der Nachricht in einem Ressourcenpfad zurück:

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

Den MLLP-Adapter lokal als Publisher testen

Wenn Sie den Adapter als Publisher testen, erstellen Sie Nachrichten, indem Sie messages.create oder messages.ingest aufrufen und eine Nachrichtendatei als Binärdaten angeben.

Der Adapter erkennt automatisch Pub/Sub-Nachrichten, die über messages.create und messages.ingest gesendet werden.

Der Adapter benachrichtigt Sie, wenn er Pub/Sub-Nachrichten abruft und sendet. Der Adapter ist ein Pub/Sub-Abonnent, daher werden diese Nachrichten automatisch bestätigt. Daher werden sie aus der Nachrichtenwarteschlange in dem Pub/Sub-Abo entfernt, das Sie mit dem Adapter konfiguriert haben.

Wenn Sie das Pub/Sub-Abo abrufen und separat überprüfen möchten, ob die Nachrichten veröffentlicht wurden, müssen Sie ein zweites Pub/Sub-Abo erstellen, das dem zuvor erstellten Thema zugewiesen ist. Die an das zweite Abo gesendeten Nachrichten werden vom Adapter nicht automatisch bestätigt und bleiben erhalten, sodass Sie sie abrufen können.

So erstellen Sie ein zweites Pub/Sub-Abo, das dem zuvor erstellten Thema zugewiesen ist:

Console

Rufen Sie in der Google Cloud Console die Seite Pub/Sub-Themen auf.

Zur Seite "Pub/Sub-Themen"
Klicken Sie auf das Thema Ihres Projekts. Dies ist das Thema, mit dem Sie das erste Abo erstellt haben.
Klicken Sie auf Abo erstellen.
Geben Sie einen Namen für das Abo ein:

projects/PROJECT_ID/subscriptions/SECOND_SUBSCRIPTION_NAME

Belassen Sie den Zustellungstyp bei Pull.
Klicken Sie auf Erstellen.

gcloud

Führen Sie den Befehl gcloud pubsub subscriptions create aus, um ein zweites Pub/Sub-Abo zu erstellen, das dem zuvor erstellten Thema zugewiesen ist:

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

Wenn die Anfrage erfolgreich ist, gibt der Befehl die folgende Ausgabe zurück:

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

Führen Sie die folgenden Schritte auf dem Computer aus, auf dem Sie das vordefinierte Docker-Image abgerufen haben, um den Adapter lokal als Publisher zu testen:

Installieren Sie Netcat:
```
sudo apt install netcat
```
Laden Sie die Datei hl7v2-mllp-ack-sample.txt herunter und speichern Sie sie auf Ihrem lokalen Computer. Die Datei enthält eine ACK-Nachricht, die der Adapter als Antwort benötigt, wenn er versucht, eine Nachricht zu veröffentlichen.
Führen Sie den folgenden Befehl aus, damit Netcat eingehende Verbindungen auf Port 2525 im Verzeichnis, in das Sie die Datei heruntergeladen haben, überwacht:
Linux
```
echo -n -e "\x0b$(cat hl7v2-mllp-ack-sample.txt)\x1c\x0d" | nc -q1 -lv -p 2525 | less
```
Nach dem Start von Netcat wird eine Ausgabenachricht wie die folgende angezeigt:
```
listening on [any] 2525 ...
```
Netcat wird als Vordergrundprozess ausgeführt. Um mit dem Testen fortzufahren, öffnen Sie ein anderes Terminal auf Ihrem lokalen Computer.
Führen Sie im neuen Terminal den folgenden Befehl aus, um den Adapter zu starten:
```
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
```
Dabei gilt:
- PROJECT_ID ist die ID für das Google Cloud-Projekt, das Ihren HL7v2-Speicher enthält.
- LOCATION ist die Region, in der sich Ihr HL7v2-Speicher befindet.
- DATASET_ID ist die ID für das übergeordnete Dataset Ihres HL7v2-Speichers.
- HL7V2_STORE_ID ist die ID des HL7v2-Speichers, an den Sie HL7v2-Nachrichten senden.
- PROJECT_ID ist die ID für das Google Cloud-Projekt, das das Pub/Sub-Thema enthält.
- PUBSUB_SUBSCRIPTION ist der Name des ersten von Ihnen erstellten Abos, das mit Ihrem Pub/Sub-Thema verknüpft war. Der Adapter verarbeitet Nachrichten aus diesem Abo und bestätigt sie automatisch. Um die für das Thema veröffentlichten Nachrichten anzuzeigen, müssen Sie Nachrichten aus dem zuvor erstellten zweiten Abo abrufen.
Nachdem Sie den vorherigen Befehl ausgeführt haben, wird der Adapter auf Ihrem lokalen Computer unter der IP-Adresse 127.0.0.1 auf Port 2575 ausgeführt.

Wenn Fehler auftreten, führen Sie die folgenden Schritte zur Fehlerbehebung aus:
- Wenn Sie Mac OS verwenden und der vorherige Befehl mit einem Connection refused-Fehler fehlschlägt, lesen Sie den Abschnitt Verbindung abgelehnt bei lokaler Ausführung.
- Wenn der vorherige Befehl mit dem Fehler healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials. See https://developers.google.com/accounts/docs/application-default-credentials for more information. fehlschlägt, lesen Sie den Abschnitt Fehler could not find default credentials bei lokaler Ausführung.
- Wenn andere Authentifizierungsfehler auftreten, lesen Sie den Hilfeartikel Authentifizierungsfehler.
Der Adapter wird als Vordergrundprozess ausgeführt. Um mit dem Testen fortzufahren, öffnen Sie ein anderes Terminal auf Ihrem lokalen Computer.

Laden Sie die Datei hl7v2-sample.json herunter und speichern Sie sie auf Ihrem lokalen Computer. Rufen Sie in dem Verzeichnis, in das Sie die Datei heruntergeladen haben, die Methode messages.create auf, um die Nachricht in einem HL7v2-Speicher zu erstellen:

curl

Um eine HL7v2-Nachricht zu erstellen, senden Sie eine POST-Anfrage und geben Sie die folgenden Informationen an:

Der Name des übergeordneten Datasets
Der Name des HL7v2-Speichers
Eine Nachricht
Ein Zugriffstoken

Das folgende Beispiel zeigt eine POST-Anfrage mit curl und einer JSON-Beispieldatei mit dem Namen 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"

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort im JSON-Format zurück:

{
  "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

Um eine HL7v2-Nachricht zu erstellen, senden Sie eine POST-Anfrage und geben Sie die folgenden Informationen an:

Der Name des übergeordneten Datasets
Der Name des HL7v2-Speichers
Eine Nachricht
Ein Zugriffstoken

Das folgende Beispiel zeigt eine POST-Anfrage mit Windows PowerShell und eine JSON-Beispieldatei namens 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

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort im JSON-Format zurück:

{
  "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"
    }
  ]
}

Nach dem Erstellen der Nachricht gibt der MLLP-Adapter eine Antwort zurück, die der folgenden ähnelt:

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.

In dem Terminal, in dem Sie Netcat ausgeführt haben, wird eine Ausgabe wie die folgende angezeigt. Diese Ausgabe gibt an, dass die Nachricht veröffentlicht wurde:
```
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^\
```
Dies entspricht dem Wert im Feld data der Antwort, die Sie beim Erstellen der Nachricht erhalten haben. Er entspricht dem Wert data in der Datei hl7v2-sample.json.

Führen Sie den Befehl gcloud pubsub subscriptions pull für das zweite von Ihnen erstellte Pub/Sub-Abo aus, um die Nachricht anzuzeigen, die der Adapter im Pub/Sub-Thema veröffentlicht hat:

gcloud pubsub subscriptions pull --auto-ack SECOND_SUBSCRIPTION

Der Befehl gibt die folgende Ausgabe zur erstellten HL7v2-Nachricht zurück. Beachten Sie den Wert publish=true in der Spalte ATTRIBUTES, der angibt, dass die Nachricht in Pub/Sub veröffentlicht wurde:

┌-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┐
|                                                               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  |
└-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘

Veröffentlichen von Nachrichten an verschiedene externe Empfänger

Sie können den HL7v2-Speicher mit mehreren Pub/Sub-Themen konfigurieren und Filter verwenden, um Benachrichtigungen an verschiedene Pub/Sub-Themen zu senden. Sie können dann einen MLLP-Adapter für jedes Pub/Sub-Thema ausführen, um die Nachrichten auf einem anderen externen Empfänger zu veröffentlichen.

So konfigurieren Sie den HL7v2-Speicher mit mehreren Pub/Sub-Themen und einem Filter für jedes Thema:

Erstellen Sie zwei Pub/Sub-Themen und ein Abo für jedes Thema. Weitere Informationen finden Sie unter Pub/Sub-Thema und -Abo erstellen.

Führen Sie dazu diesen Befehl aus:

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"

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort im JSON-Format zurück:

{
  "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

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort im JSON-Format zurück:

{
  "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\""
    }
  ]
}

Testen Sie das Nachrichtenrouting

Führen Sie die Schritte in den folgenden Abschnitten aus, um das Nachrichtenrouting zu testen.

Konfigurieren und Starten des ersten Empfängers und Adapters

Führen Sie die folgenden Schritte aus, um den ersten Empfänger und Adapter zu konfigurieren und zu starten:

Führen Sie auf dem Computer, auf dem Sie das vordefinierte Docker-Image abgerufen haben, den folgenden Befehl aus, um Netcat zu installieren:
```
sudo apt install netcat
```
Laden Sie hl7v2-mllp-ack-sample.txt herunter, falls noch nicht geschehen. Die Datei enthält eine ACK-Nachricht, die vom Adapter als Antwort verwendet wird, wenn versucht wird, eine Nachricht zu veröffentlichen.
Führen Sie den folgenden Befehl aus, um Port 2525 für den ersten Empfänger festzulegen:
Linux
```
echo -n -e "\x0b$(cat hl7v2-mllp-ack-sample.txt)\x1c\x0d" | nc -q1 -lv -p 2525 | less
```
Wenn der Netcat-Prozess gestartet wird, wird die folgende Ausgabe angezeigt:
```
listening on [any] 2525 ...
```
Führen Sie den folgenden Befehl aus, um den ersten Adapter in einem neuen Terminal zu starten:
```
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
```
Dabei gilt:
- PROJECT_ID ist die ID für das Google Cloud-Projekt, das Ihren HL7v2-Speicher enthält.
- LOCATION ist die Region, in der sich Ihr HL7v2-Speicher befindet.
- DATASET_ID ist die ID für das übergeordnete Dataset Ihres HL7v2-Speichers.
- HL7V2_STORE_ID ist die ID des HL7v2-Speichers, an den Sie HL7v2-Nachrichten senden.
- PROJECT_ID ist die ID für das Google Cloud-Projekt, das das Pub/Sub-Thema enthält.
- PUBSUB_SUBSCRIPTION ist der Name des ersten von Ihnen erstellten Abos, das mit Ihrem ersten Pub/Sub-Thema verknüpft ist. Der Adapter verarbeitet Nachrichten aus diesem Abo und bestätigt sie automatisch.
Nachdem Sie diesen Befehl ausgeführt haben, beginnt die Ausführung des Adapters auf Ihrem lokalen Computer um 127.0.0.1:2575. Damit werden neue Nachrichten an den ersten externen Empfänger auf Port 2525 veröffentlicht.

Wichtig: Wenn Sie Mac OS verwenden und dieser Befehl mit dem Fehler Connection refused fehlschlägt, lesen Sie den Abschnitt Fehler Verbindung abgelehnt bei lokaler Ausführung. Wenn dieser Befehl mit dem Fehler could not find default credentials fehlschlägt, lesen Sie den Abschnitt Fehler could not find default credentials bei lokaler Ausführung.

Konfigurieren und Starten des zweiten Empfängers und Adapters

Führen Sie die folgenden Schritte aus, um den zweiten Empfänger und Adapter zu konfigurieren und zu starten:

Führen Sie auf dem Computer, auf dem Sie das vordefinierte Docker-Image abgerufen haben, den folgenden Befehl aus, um Netcat zu installieren:
```
sudo apt install netcat
```
Laden Sie hl7v2-mllp-ack-sample.txt herunter, falls noch nicht geschehen. Die Datei enthält eine ACK-Nachricht, die vom Adapter als Antwort verwendet wird, wenn versucht wird, eine Nachricht zu veröffentlichen.
Führen Sie den folgenden Befehl aus, um Port 2526 für den zweiten Empfänger festzulegen.
Linux
```
echo -n -e "\x0b$(cat hl7v2-mllp-ack-sample.txt)\x1c\x0d" | nc -q1 -lv -p 2526 | less
```
Wenn der Netcat-Prozess gestartet wird, wird die folgende Ausgabe angezeigt:
```
listening on [any] 2526 ...
```
Führen Sie den folgenden Befehl aus, um den zweiten Adapter in einem neuen Terminal zu starten:
```
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
```
Dabei gilt:
- PROJECT_ID ist die ID für das Google Cloud-Projekt, das Ihren HL7v2-Speicher enthält.
- LOCATION ist die Region, in der sich Ihr HL7v2-Speicher befindet.
- DATASET_ID ist die ID für das übergeordnete Dataset Ihres HL7v2-Speichers.
- HL7V2_STORE_ID ist die ID des HL7v2-Speichers, an den Sie HL7v2-Nachrichten senden.
- PROJECT_ID ist die ID für das Google Cloud-Projekt, das das Pub/Sub-Thema enthält.
- SECOND_PUBSUB_SUBSCRIPTION ist der Name des zweiten von Ihnen erstellten Abos, das mit Ihrem zweiten Pub/Sub-Thema verknüpft ist. Der Adapter verarbeitet Nachrichten aus diesem Abo und bestätigt sie automatisch.
Nachdem Sie diesen Befehl ausgeführt haben, wird der Adapter auf Ihrem lokalen Computer über die IP-Adresse Port 127.0.0.1:2576 ausgeführt. Es veröffentlicht neue Nachrichten an den zweiten externen Empfänger auf Port 2526.

Wichtig: Wenn Sie Mac OS verwenden und dieser Befehl mit dem Fehler Connection refused fehlschlägt, lesen Sie den Abschnitt Fehler Verbindung abgelehnt bei lokaler Ausführung. Wenn dieser Befehl mit dem Fehler could not find default credentials. fehlschlägt, lesen Sie den Abschnitt Fehler could not find default credentials bei lokaler Ausführung.

Veröffentlichen einer Nachricht für den ersten Empfänger

So erstellen Sie eine Nachricht, die nur für den ersten externen Empfänger veröffentlicht wird:

hl7v2-sample1.json herunterladen.

Rufen Sie in dem Verzeichnis, in das Sie hl7v2-sample1.json heruntergeladen haben, die Methode messages.create auf, um die Nachricht in einem HL7v2-Speicher zu erstellen:

curl

Um eine HL7v2-Nachricht zu erstellen, senden Sie eine POST-Anfrage und geben Sie die folgenden Informationen an:

Der Name des übergeordneten Datasets
Der Name des HL7v2-Speichers
Eine Nachricht
Ein Zugriffstoken

Das folgende Beispiel zeigt eine POST-Anfrage mit curl und der JSON-Beispieldatei 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"

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort im JSON-Format zurück:

{
 "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

Um eine HL7v2-Nachricht zu erstellen, senden Sie eine POST-Anfrage und geben Sie die folgenden Informationen an:

Der Name des übergeordneten Datasets
Der Name des HL7v2-Speichers
Eine Nachricht
Ein Zugriffstoken

Das folgende Beispiel zeigt eine POST-Anfrage mit Windows PowerShell und eine JSON-Beispieldatei namens 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

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort im JSON-Format zurück:

{
 "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"
   }
 ]
}

In dieser Antwort ist sendFacility auf SEND_FACILITY_1 gesetzt, sodass die Pub/Sub-Benachrichtigung nur an das erste Pub/Sub-Thema gesendet wird. Nach dem Erstellen der Nachricht gibt der erste MLLP-Adapter die folgende Antwort zurück:

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.

Der zweite MLLP-Adapter gibt keine Antwort zurück, da keine Benachrichtigung an das zweite Pub/Sub-Thema gesendet wird.

In dem Terminal, in dem Sie den ersten Netcat-Prozess ausgeführt haben, wird die folgende Ausgabe angezeigt. Diese Ausgabe gibt an, dass die Nachricht veröffentlicht wurde.

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^\

Diese Ausgabe entspricht dem Wert im Feld data der Antwort, die Sie beim Erstellen der Nachricht erhalten haben. Er entspricht dem Wert data in der Datei hl7v2-sample1.json.

Veröffentlichen einer Nachricht für den zweiten Empfänger

So erstellen Sie eine Nachricht, die nur für den zweiten externen Empfänger veröffentlicht wird:

Öffnen Sie ein neues Terminal auf Ihrem lokalen Computer.
Wenn Sie eine Nachricht erstellen möchten, die nur für den zweiten externen Empfänger veröffentlicht wird, laden Sie hl7v2-sample2.json herunter.

Rufen Sie in dem Verzeichnis, in das Sie hl7v2-sample2.json heruntergeladen haben, die Methode messages.create auf, um die Nachricht in einem HL7v2-Speicher zu erstellen:

curl

Um eine HL7v2-Nachricht zu erstellen, senden Sie eine POST-Anfrage und geben Sie die folgenden Informationen an:

Der Name des übergeordneten Datasets
Der Name des HL7v2-Speichers
Eine Nachricht
Ein Zugriffstoken

Das folgende Beispiel zeigt eine POST-Anfrage mit curl und der JSON-Beispieldatei 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"

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort im JSON-Format zurück:

{
 "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

Um eine HL7v2-Nachricht zu erstellen, senden Sie eine POST-Anfrage und geben Sie die folgenden Informationen an:

Der Name des übergeordneten Datasets
Der Name des HL7v2-Speichers
Eine Nachricht
Ein Zugriffstoken

Das folgende Beispiel zeigt eine POST-Anfrage mit Windows PowerShell und die JSON-Beispieldatei 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

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort im JSON-Format zurück:

{
 "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"
   }
 ]
}

Beachten Sie, dass "sendFacility" SEND_FACILITY_2 ist, daher wird die Pub/Sub-Benachrichtigung nur an das zweite Pub/Sub-Thema gesendet. Nach dem Erstellen der Nachricht gibt der erste MLLP-Adapter keine Antwort zurück, während der zweite MLLP-Adapter die folgende Antwort zurückgibt:

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.

In dem Terminal, auf dem Sie den zweiten Netcat-Prozess ausgeführt haben, wird die folgende Ausgabe angezeigt. Diese Ausgabe gibt an, dass die Nachricht veröffentlicht wurde.

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^\

Diese Ausgabe entspricht dem Wert im Feld data der Antwort, die Sie beim Erstellen der Nachricht erhalten haben. Er entspricht dem Wert data in der Datei hl7v2-sample2.json.

MLLP-Adapter in Google Kubernetes Engine bereitstellen

Wenn Sie HL7v2-Nachrichten über MLLP von Ihrem Pflegezentrum übertragen, können Sie die Nachrichten an einen in Google Cloud bereitgestellten Adapter senden und an die Cloud Healthcare API weiterleiten.

Der MLLP-Adapter wird als zustandslose Anwendung in einem GKE-Cluster ausgeführt. Ein GKE-Cluster ist eine verwaltete Gruppe von VM-Instanzen zum Ausführen von containerisierten Anwendungen. Zustandslose Anwendungen sind Anwendungen, die weder Daten noch den Anwendungsstatus im Cluster oder im nichtflüchtigen Speicher speichern. Stattdessen bleiben Daten und Anwendungsstatus beim Client. Das macht zustandslose Anwendungen skalierbarer.

GKE verwendet den Deployment-Controller zum Bereitstellen zustandsloser Anwendungen als einheitliche, nicht eindeutige Pods. Deployments verwalten dabei den gewünschten Status einer Anwendung und geben Antworten auf Fragen wie "Wie viele Pods sollten die Anwendung ausführen?", "Welche Version des Container-Images sollte ausgeführt werden?", "Welche Labels sollten die Pods haben?" usw. Der gewünschte Status kann dynamisch durch Aktualisieren der Pod-Spezifikation des Deployments geändert werden.

Bei der Bereitstellung des Adapters erstellen Sie einen Dienst-Controller, mit dem Sie den Adapter mit der Cloud Healthcare API unter Verwendung des internen Load-Balancing verbinden können.

Wenn Sie neu bei GKE sind, sollten Sie den GKE-Schnellstart ausführen, um zu erfahren, wie das Produkt funktioniert.

Pub/Sub API-Berechtigungen zum GKE-Dienstkonto hinzufügen

Wie in der GKE-Dokumentation zur Authentifizierung bei der Cloud Platform mit Dienstkonten beschrieben, ist jeder Knoten in einem Containercluster eine Compute Engine-Instanz. Wenn der MLLP-Adapter auf einem Containercluster ausgeführt wird, übernimmt er daher automatisch die Bereiche der Compute Engine-Instanzen, in denen er bereitgestellt wird.

Google Cloud erstellt automatisch ein Dienstkonto mit dem Namen "Compute Engine-Standarddienstkonto" und GKE verknüpft dieses Dienstkonto mit den von GKE erstellten Knoten. Je nach Konfiguration Ihres Projekts verfügt das Standarddienstkonto möglicherweise über Berechtigungen zur Verwendung anderer Cloud Platform APIs. GKE weist Compute Engine-Instanzen auch einige eingeschränkte Zugriffsbereiche zu.

Die besten Ergebnisse erzielen Sie, wenn Sie sich nicht bei anderen Google Cloud-Diensten (z. B. Pub/Sub) von Pods authentifizieren, die in GKE ausgeführt werden, indem Sie die Berechtigungen des Standarddienstkontos aktualisieren oder Compute Engine-Instanzen weitere Zugriffsbereiche zuweisen. Erstellen Sie stattdessen Ihre eigenen Dienstkonten.

Sie müssen dem Containercluster die erforderlichen Pub/Sub-Berechtigungen erteilen, aber auch die Berechtigung zum Schreiben von Messwerten in Cloud Monitoring.

Führen Sie die folgenden Schritte aus, um ein neues Dienstkonto zu erstellen, das nur die für den Containercluster erforderlichen Bereiche enthält:

Console

Erstellen Sie ein Dienstkonto:

Wechseln Sie in der Google Cloud Console zur Seite Dienstkonto erstellen.

Zur Seite „Dienstkonto erstellen“
Wählen Sie ein Projekt aus.
Geben Sie im Feld Dienstkontoname einen Namen ein. Die Google Cloud Console füllt das Feld Dienstkonto-ID anhand dieses Namens aus.

Optional: Geben Sie im Feld Dienstkontobeschreibung eine Beschreibung ein.
Klicken Sie auf Erstellen.
Klicken Sie auf das Feld Rolle auswählen.

Klicken Sie unter Alle Rollen auf Pub/Sub > Pub/Sub-Subscriber.
Klicken Sie auf Weitere Rolle hinzufügen und dann auf das Feld Rolle auswählen.

Klicken Sie unter Alle Rollen auf Cloud Healthcare > Healthcare HL7v2 Nachrichtenaufnahme.
Optional: Wenn Sie das Monitoring aktivieren möchten, klicken Sie auf Weitere Rolle hinzufügen und dann auf das Feld Rolle auswählen.

Klicken Sie unter Alle Rollen auf Monitoring > Monitoring-Messwert-Autor.
Klicken Sie auf Weiter.
Klicken Sie auf Fertig, um das Erstellen des Dienstkontos abzuschließen.

Schließen Sie das Browserfenster nicht. Sie verwenden das Fenster im nächsten Schritt.

gcloud

Führen Sie den Befehl gcloud iam service-accounts create aus, um das Dienstkonto zu erstellen.
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
Die Ausgabe ist das Dienstkonto:
```
Created service account SERVICE_ACCOUNT_NAME.
```

Führen Sie den Befehl gcloud projects add-iam-policy-binding aus, um dem Dienstkonto jede Rolle zuzuweisen.

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

Die Ausgabe enthält die aktualisierte Richtlinie:

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

Cluster erstellen

Führen Sie den Befehl gcloud container clusters create aus, um den Cluster in GKE zu erstellen:

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

wobei

COMPUTE_ZONE ist die Zone, in der Ihr Cluster bereitgestellt wird. Eine Zone ist ein ungefährer regionaler Standort, an dem sich Ihre Cluster und deren Ressourcen befinden. us-west1-a ist z. B. eine Zone in der Region us-west. Wenn Sie eine Standardzone mit gcloud config set compute/zone festgelegt haben, überschreibt der Wert dieses Flags den Standardwert.
CLIENT_EMAIL ist die Kennung für das Dienstkonto, das Sie verwenden möchten. Sie hat das Format SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.

Der Befehl gibt eine Ausgabe ähnlich dem folgenden Beispiel zurück:

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

Nach dem Erstellen des Clusters erstellt GKE drei Compute Engine-VM-Instanzen. Sie können dies überprüfen, indem Sie die Instanzen mit dem folgenden Befehl auflisten:

gcloud compute instances list

Bereitstellung konfigurieren

Wenn Sie eine Anwendung in GKE bereitstellen, definieren Sie die Eigenschaften der Bereitstellung mithilfe einer Bereitstellungsmanifestdatei, bei der es sich in der Regel um eine YAML-Datei handelt. Ein Beispiel finden Sie unter Bereitstellung erstellen.

Öffnen Sie ein separates Terminal.
Erstellen Sie mit einem Texteditor eine Bereitstellungsmanifestdatei namens mllp_adapter.yaml mit folgendem Inhalt:

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"

Dabei gilt:

PROJECT_ID ist die ID für das Google Cloud-Projekt, das Ihren HL7v2-Speicher enthält.
LOCATION ist die Region, in der sich Ihr HL7v2-Speicher befindet.
DATASET_ID ist die ID für das übergeordnete Dataset Ihres HL7v2-Speichers.
HL7V2_STORE_ID ist die ID des HL7v2-Speichers, an den Sie HL7v2-Nachrichten senden.

Die Bereitstellung hat die folgenden Eigenschaften:

spec: replicas: ist die Anzahl der replizierten Pods, die vom Deployment verwaltet werden.
spec: template: metadata: labels: ist das Label für jeden Pod, das vom Deployment zum Verwalten der Pods verwendet wird.
spec: template: spec: ist die Pod-Spezifikation, mit der definiert wird, wie jeder Pod ausgeführt werden soll.
spec: containers enthält den Namen des in jedem Pod auszuführenden Containers sowie das auszuführende Container-Image.

Weitere Informationen zur Bereitstellungsspezifikation finden Sie in der Referenz zur Deployment API.

Konfigurieren Sie den Dienst

Damit der MLLP-Adapter für Anwendungen außerhalb des Clusters zugänglich ist (z. B. ein Pflegezentrum), müssen Sie einen internen Load-Balancer konfigurieren.

Wenn Sie kein VPN konfiguriert haben, können Anwendungen über den internen Load-Balancer auf den MLLP-Adapter zugreifen, solange die Anwendungen dasselbe VPC-Netzwerk verwenden und sich in derselben Google Cloud-Region befinden. Um beispielsweise den Adapter für eine Compute Engine-VM-Instanz in derselben Region und im selben VPC-Netzwerk zugänglich zu machen, können Sie dem Dienst des Clusters einen internen Load-Balancer hinzufügen. Ressource.

Erstellen Sie in dem Verzeichnis, in dem Sie die Manifestdatei der Bereitstellung erstellt haben, mit dem Texteditor eine Dienstmanifestdatei namens mllp_adapter_service.yaml mit folgendem Inhalt. Diese Datei ist für die Konfiguration des internen Lastenausgleichs verantwortlich:

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

Der Dienst hat die folgenden Eigenschaften:

metadata: name: der Name ist, den Sie für den Dienst auswählen. In diesem Fall handelt es sich um mllp-adapter-service.
metadata: annotations: ist eine Annotation, die angibt, dass ein interner Load-Balancer konfiguriert werden soll.
spec: type: ist der Typ des Load-Balancers.
ports: port: wird verwendet, um den Port anzugeben, über den der Dienst Traffic von anderen Diensten im selben Cluster empfangen kann. Der MLLP-Standardport von 2575 wird verwendet.
ports: targetPort: wird verwendet, um den Port auf jedem Pod anzugeben, auf dem der Dienst ausgeführt wird.
spec: selector: app: gibt die Pods an, auf die der Dienst abzielt.

Obwohl es möglich ist, eine IP-Adresse für das Lastenausgleichsmodul über das Feld clusterIP anzugeben, kann das Lastenausgleichsmodul eine eigene IP-Adresse generieren, an die Sie Nachrichten senden können. Warten Sie zuerst, bis der Cluster die IP-Adresse generiert hat, die Sie später in dieser Anleitung verwenden.

Weitere Informationen zum internen Lastenausgleich finden Sie in der GKE-Dokumentation.

Weitere Informationen zur Dienstspezifikation finden Sie in der Referenz zur Service API.

Bereitstellung bereitstellen

Führen Sie den folgenden Befehl aus, um den Adapter in einem Verzeichnis mit der Manifestdatei der Bereitstellung mllp_adapter.yaml in einem GKE-Cluster bereitzustellen:

kubectl apply -f mllp_adapter.yaml

Der Befehl gibt die folgende Ausgabe zurück:

deployment.extensions "mllp-adapter-deployment" created

Deployment überprüfen

Nachdem Sie die Bereitstellung erstellt haben, können Sie sie mit dem kubectl-Tool überprüfen.

Führen Sie den folgenden Befehl aus, um ausführliche Informationen zum Deployment zu erhalten:

kubectl describe deployment mllp-adapter

Führen Sie den folgenden Befehl aus, um den von der Bereitstellung erstellten Pod aufzulisten:

kubectl get pods -l app=mllp-adapter

So rufen Sie Informationen zum erstellten Pod ab:

kubectl describe pod POD_NAME

Wenn die Bereitstellung erfolgreich war, sollte der letzte Teil der Ausgabe des vorherigen Befehls die folgenden Informationen enthalten:

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

Dienst bereitstellen und den internen Load-Balancer erstellen

Führen Sie den folgenden Befehl aus, um den internen Load-Balancer in dem Verzeichnis zu erstellen, das die Manifestdatei des Dienstes mllp_adapter_service.yaml enthält:

kubectl apply -f mllp_adapter_service.yaml

Der Befehl gibt die folgende Ausgabe zurück:

service "mllp-adapter-service" created

Dienst prüfen

Nachdem Sie den Dienst erstellt haben, prüfen Sie, ob er erfolgreich konfiguriert wurde.

Führen Sie den folgenden Befehl aus, um den internen Load-Balancer zu überprüfen:

kubectl describe service mllp-adapter-service

Die Ausgabe des Befehls sieht in etwa so aus:

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

Es kann bis zu einer Minute dauern, bis die IP-Adresse LoadBalancer Ingress ausgefüllt ist. Im nächsten Schritt verwenden Sie diese IP-Adresse und den Port 2575, um von außerhalb des Clusters auf den Dienst zuzugreifen.

Compute Engine-VM erstellen und Nachrichten senden

Während Sie in dieser Anleitung den MLLP-Adapter lokal getestet und HL7v2-Nachrichten an Ihren HL7v2-Speicher gesendet haben, senden Sie jetzt Nachrichten von einer Compute Engine-VM an den in GKE ausgeführten MLLP-Adapter. Die Nachrichten werden dann an einen HL7v2-Speicher weitergeleitet.

Um Anfragen von der neuen Instanz an den GKE-Cluster zu senden, müssen sich die Instanz und die vorhandenen Instanzen in derselben Region befinden und dasselbe VPC-Netzwerk verwenden.

Am Ende dieses Abschnitts werden die in Ihrem Pub/Sub-Thema veröffentlichten Benachrichtigungen und die HL7v2-Nachrichten in Ihrem HL7v2-Speicher aufgelistet. Der Compute Engine-VM-Instanz müssen Berechtigungen zum Ausführen dieser Aufgaben erteilt werden. Erstellen Sie vor dem Erstellen der Instanz ein neues Dienstkonto mit den erforderlichen Berechtigungen. Führen Sie dazu die folgenden Schritte aus:

Console

Erstellen Sie ein Dienstkonto:

Wechseln Sie in der Google Cloud Console zur Seite Dienstkonto erstellen.

Zur Seite „Dienstkonto erstellen“
Wählen Sie ein Projekt aus.
Geben Sie im Feld Dienstkontoname einen Namen ein. Die Google Cloud Console füllt das Feld Dienstkonto-ID anhand dieses Namens aus.

Optional: Geben Sie im Feld Dienstkontobeschreibung eine Beschreibung ein.
Klicken Sie auf Erstellen.
Klicken Sie auf das Feld Rolle auswählen.

Klicken Sie unter Alle Rollen auf Pub/Sub > Pub/Sub-Subscriber.
Klicken Sie auf Weitere Rolle hinzufügen und dann auf das Feld Rolle auswählen.

Klicken Sie unter Alle Rollen auf Cloud Healthcare > Healthcare HL7v2 Nachrichtennutzer.
Klicken Sie auf Weiter.
Klicken Sie auf Fertig, um das Erstellen des Dienstkontos abzuschließen.

Schließen Sie das Browserfenster nicht. Sie verwenden das Fenster im nächsten Schritt.

gcloud

Führen Sie den Befehl gcloud iam service-accounts create aus, um das Dienstkonto zu erstellen.
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
Die Ausgabe ist das Dienstkonto:
```
Created service account SERVICE_ACCOUNT_NAME.
```

Führen Sie den Befehl gcloud projects add-iam-policy-binding aus, um dem Dienstkonto jede Rolle zuzuweisen.

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

Die Ausgabe enthält die aktualisierte Richtlinie:

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

Die folgenden Schritte zeigen, wie Sie eine Linux-VM-Instanz in Compute Engine erstellen:

Console

Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.

Die Seite VM-Instanzen aufrufen
Klicken Sie auf Instanz erstellen.
Wählen Sie eine Region und eine Zone für die Instanz aus, die der Zone entspricht, die Sie beim Erstellen des Clusters ausgewählt haben. Wenn Sie beispielsweise beim Erstellen des Clusters us-central1-a für COMPUTE_ZONE verwendet haben, wählen Sie im Bildschirm zur Instanzerstellung us-central1 (Iowa) für die Region und us-central1-a für die Zone aus.
Klicken Sie im Abschnitt Bootlaufwerk auf Ändern, um mit der Konfiguration des Bootlaufwerks zu beginnen.
Wählen Sie auf dem Tab Öffentliche Images die Version 9 des Debian-Betriebssystems aus.
Klicken Sie auf Auswählen.
Wählen Sie im Abschnitt Identität und API-Zugriff das von Ihnen erstellte Dienstkonto aus.
Wählen Sie im Bereich Firewall die Option HTTP-Traffic zulassen aus.
Erstellen klicken, um die Instanz zu erstellen.

gcloud

Führen Sie zum Erstellen einer Compute-Instanz die Methode gcloud compute instances create mit den folgenden Optionen aus:

Die ZONE, die Sie beim Erstellen des Clusters ausgewählt haben
Das http-server-Tag, das HTTP-Traffic zulässt
Die von Ihnen erstellte 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

Die Ausgabe ähnelt dem folgenden Beispiel:

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

Warten Sie, bis die Instanz gestartet ist. Nachdem die Instanz gestartet wurde, wird sie auf der Seite "VM-Instanzen" mit einem grünen Statussymbol angezeigt.

Standardmäßig verwendet die Instanz dasselbe Standard-VPC-Netzwerk wie der Cluster. Das bedeutet, dass Traffic von der Instanz an den Cluster gesendet werden kann.

So stellen Sie eine Verbindung zur Instanz her:

Console

Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.
Die Seite VM-Instanzen aufrufen
Klicken Sie in der Liste der VM-Instanzen in der Zeile der von Ihnen erstellten Instanz auf SSH.

gcloud

Führen Sie den Befehl gcloud compute ssh aus, um eine Verbindung zur Instanz herzustellen:

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

Sie haben nun ein Terminalfenster, über das Sie mit Ihrer Linux-Instanz interagieren können.

Installieren Sie im Terminalfenster Netcat:
```
sudo apt install netcat
```
Laden Sie die Datei hl7v2-mllp-sample.txt herunter und speichern Sie sie in der Instanz. Informationen zu den in der Datei verwendeten Codierungs- und Segmentabschlusszeichen finden Sie unter HL7v2-Nachrichtensegment-Trennzeichen und Codierung.
Führen Sie den folgenden Befehl aus, um HL7v2-Nachrichten über den MLLP-Adapter an Ihren HL7v2-Speicher in dem Verzeichnis zu senden, in das Sie die Datei heruntergeladen haben. Verwenden Sie den Wert von LoadBalancer Ingress, der beim Überprüfen des Dienstes angezeigt wurde.
```
echo -n -e "\x0b$(cat hl7v2-mllp-sample.txt)\x1c\x0d" | nc LOAD_BALANCER_INGRESS_IP_ADDRESS 2575
```
Nachdem Sie den Befehl ausgeführt haben, wird die Nachricht über den MLLP-Adapter an Ihren HL7v2-Speicher gesendet. Wenn die Nachricht erfolgreich in den HL7v2-Speicher aufgenommen wurde, gibt der Befehl die folgende Ausgabe zurück:
```
MSA|AA|20150503223000|ILITY|FROM_APP|FROM_FACILITY|20190312162410||ACK|f4c59243-19c2-4373-bea0-39c1b2ba616b|P|2.5
```
Diese Ausgabe gibt an, dass der HL7v2-Speicher mit dem Antworttyp AA (Application Accept) geantwortet hat. Dies bedeutet, dass die Nachricht validiert und erfolgreich aufgenommen wurde.

Führen Sie den Befehl gcloud pubsub subscriptions pull aus, um die im Pub/Sub-Thema veröffentlichte Nachricht anzuzeigen:

gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION

Der Befehl gibt die folgende Ausgabe zur aufgenommenen HL7v2-Nachricht zurück:

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

Sie können auch die Nachrichten in Ihrem HL7v2-Speicher auflisten, um zu sehen, ob die Nachricht hinzugefügt wurde:

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"

Wenn die Anfrage erfolgreich ist, gibt der Server die ID der Nachricht in einem Ressourcenpfad zurück:

{
  "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

Wenn die Anfrage erfolgreich ist, gibt der Server die ID der Nachricht in einem Ressourcenpfad zurück:

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

Nach Abschluss dieses Abschnitts haben Sie den MLLP-Adapter erfolgreich in GKE bereitgestellt und eine HL7v2-Nachricht von einer Remoteinstanz über den Adapter und die Cloud Healthcare API gesendet.

In dieser Anleitung erfahren Sie, wie Sie die übertragenen HL7v2-Nachrichten sicher verschlüsseln, indem Sie ein VPN zwischen einer Compute Engine-Instanz, die als "lokale" Instanz fungiert, und dem Adapter konfigurieren.

VPN konfigurieren

Mit einem VPN können Sie das private Netzwerk, an das Sie HL7v2-Nachrichten über ein öffentliches Netzwerk wie das Internet senden, erweitern. Wenn Sie ein VPN verwenden, können Sie Nachrichten von Ihrem Pflegezentrum über den MLLP-Adapter und an Google Cloud senden. Die Systeme in diesem Ablauf verhalten sich so, als befänden sie sich in einem einzelnen privaten Netzwerk.

Es gibt zwei Möglichkeiten, Ihre MLLP-Verbindung über ein VPN zu sichern:

Cloud VPN verwenden
Verwendung der Strongswan on Docker End-to-End-VPN-Lösung

Cloud VPN konfigurieren

Cloud VPN verbindet Ihr lokales Netzwerk über eine IPsec-VPN-Verbindung sicher mit Ihrem Google Cloud Virtual Private Cloud (VPC)-Netzwerk. Der Traffic zwischen den beiden Netzwerken ist durch ein VPN-Gateway verschlüsselt und wird anschließend von dem anderen VPN-Gateway wieder entschlüsselt. Dadurch werden Ihre Daten geschützt, während sie über das Internet oder über ein Netzwerk in einem Pflegezentrum übertragen werden.

In dieser Anleitung befindet sich jedes von Ihnen konfigurierte VPN-Gateway in einem anderen benutzerdefinierten Netzwerk und Subnetz in einer anderen Google Cloud-Region.

Das in us-central1 konfigurierte VPN-Gateway fungiert als Cloud VPN-Gateway auf Google Cloud-Seite, während das Cloud VPN-Gateway in europe-west1 Ihr "lokales" Gateway simuliert.

Benennung und Adressierung

In dieser Anleitung werden die folgenden Benennungen und IP-Adressen verwendet:

Google Cloud-Side

Netzwerkname: cloud-vpn-network
Subnetzname: subnet-us-central-10-0-1
Region: us-central1
Subnetzbereich: 10.0.1.0/24
Name der externen IP-Adresse: cloud-vpn-ip
VPN-Gateway-Name: vpn-us-central
VPN-Tunnel-Name: vpn-us-central-tunnel-1

Lokal

Netzwerkname: on-prem-vpn-network
Subnetzname: subnet-europe-west-10-0-2
Region: europe-west1
Subnetzbereich: 10.0.2.0/24
Name der externen IP-Adresse: on-prem-vpn-ip
VPN-Gateway-Name: vpn-europe-west
VPN-Tunnel-Name: vpn-europe-west-tunnel-1

Benutzerdefinierte VPC-Netzwerke und Subnetze erstellen

Der erste Schritt bei der Konfiguration von Cloud VPN besteht darin, zwei VPC-Netzwerke zu erstellen. Ein Netzwerk namens on-prem-vpn-network ist in der lokalen Umgebung konfiguriert und wird auf einer Compute Engine-VM-Instanz namens on-prem-instance ausgeführt. Das andere Netzwerk namens cloud-vpn-network wird vom GKE-Cluster verwendet, auf dem der MLLP-Adapter ausgeführt wird. Sie stellen eine Verbindung zur VM on-prem-instance her und senden HL7v2-Nachrichten über den internen Load-Balancer des MLLP-Adapters an den MLLP-Adapter, der im Netzwerk cloud-vpn-network ausgeführt wird.

Erstellen Sie zwei benutzerdefinierte VPC-Netzwerke und ihre Subnetze, indem Sie die folgenden Schritte ausführen:

Führen Sie den folgenden Befehl aus, um das erste VPC-Netzwerk cloud-vpn-network zu erstellen:

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

Führen Sie den folgenden Befehl aus, um das Subnetz subnet-us-central-10-0-1 für das Netzwerk cloud-vpn-network zu erstellen:

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

Führen Sie den folgenden Befehl aus, um das VPC-Netzwerk on-prem-vpn-network zu erstellen:

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

Führen Sie den folgenden Befehl aus, um das Subnetz subnet-europe-west-10-0-2 für das VPC-Netzwerk on-prem-vpn-network zu erstellen:

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

Erstellen einer externen IP-Adresse

Bevor Sie die VPN-Gateways erstellen, sollten Sie für jedes Gateway eine externe IP-Adresse reservieren. Gehen Sie dazu wie folgt vor:

Führen Sie den folgenden Befehl aus, um eine regionale externe (statische) IP-Adresse für die cloud-vpn-ip-Adresse zu reservieren:
```
gcloud compute addresses create cloud-vpn-ip \
   --project=PROJECT_ID \
   --region=us-central1
```
Führen Sie den folgenden Befehl aus, um eine regionale externe (statische) IP-Adresse für die on-prem-vpn-ip-Adresse zu reservieren:
```
gcloud compute addresses create on-prem-vpn-ip \
   --project=PROJECT_ID \
   --region=europe-west1
```

Notieren Sie sich die externen IP-Adressen, damit Sie die VPN-Gateways im nächsten Abschnitt konfigurieren können. Führen Sie den folgenden Befehl aus, um die externen IP-Adressen abzurufen:

Cloud VPN-IP-Adresse:

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

"Lokale" VPN-IP-Adresse:

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

Die Befehle geben in etwa folgende Ausgabe zurück:

address: 203.0.113.1

VPN-Gateways, Tunnel und Routen erstellen

Führen Sie die folgenden Schritte aus, um das VPN-Gateway, den Tunnel und die Route für das Cloud VPN zu erstellen:

Erstellen Sie einen kryptografisch starken vorinstallierten Schlüssel (gemeinsames Secret). Folgen Sie dazu der Anleitung unter Starken vorinstallierten Schlüssel generieren. Dieser Schlüssel wird in diesem Abschnitt als SHARED_SECRET bezeichnet.

Führen Sie den folgenden Befehl aus, um das Ziel-VPN-Gateway -Objekt zu erstellen:

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

Zum Erstellen von drei Weiterleitungsregeln führen Sie die folgenden Befehle aus. Ersetzen Sie dabei die Variable CLOUD_VPN_EXTERNAL_ADDRESS durch den Wert aus der Cloud VPN-IP-Adresse im vorherigen Abschnitt:

Senden Sie ESP-Traffic (IPsec) an das Gateway:

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

Senden Sie UDP 500-Traffic an das Gateway:

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

Senden Sie UDP 4500-Traffic an das Gateway:

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

Führen Sie den folgenden Befehl aus, um einen Tunnel im Cloud VPN-Gateway zu erstellen. Ersetzen Sie ON_PREM_VPN_IP durch den Wert der "lokalen" VPN-IP-Adresse aus dem vorherigen Abschnitt.

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

Führen Sie den folgenden Befehl aus, um eine statische Route zu 10.0.2.0/24 zu erstellen:

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"

Führen Sie die folgenden Schritte aus, um das VPN-Gateway, den Tunnel und die Route für das "lokale" VPN zu erstellen:

Führen Sie den folgenden Befehl aus, um das Ziel-VPN-Gateway -Objekt zu erstellen:

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

Führen Sie die folgenden Befehle aus, um drei Weiterleitungsregeln zu erstellen. Ersetzen Sie dabei die Variable ON_PREMISES_VPN_EXTERNAL_ADDRESS durch den Wert aus der lokalen VPN-IP-Adresse im vorherigen Abschnitt:

Senden Sie ESP-Traffic (IPsec) an das Gateway:

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

Senden Sie UDP 500-Traffic an das Gateway:

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

Senden Sie UDP 4500-Traffic an das Gateway:

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

Führen Sie den folgenden Befehl aus, um einen Tunnel im lokalen Gateway zu erstellen:

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

Führen Sie den folgenden Befehl aus, um eine statische Route zu 10.0.1.0/24 zu erstellen:

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"

Sie haben die Cloud VPN- und "lokalen" Gateways erstellt und deren Tunnel initiiert. Die VPN-Gateways stellen erst dann eine Verbindung her, wenn Sie Firewallregeln erstellt haben, die Traffic durch den Tunnel zwischen ihnen zulassen.

Firewallregeln erstellen

Sie müssen Firewallregeln für beide Seiten des VPN-Tunnels erstellen. Diese Regeln lassen den gesamten TCP-, UDP- und ICMP-Traffic vom Subnetz auf einer Seite des VPN-Tunnels auf die andere Seite zu.

Führen Sie den folgenden Befehl aus, um die Firewallregeln für das Cloud VPN-Subnetz zu erstellen:

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

Führen Sie den folgenden Befehl aus, um die Firewallregeln für das "lokale" Subnetz zu erstellen:

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

Erstellen Sie eine Firewallregel, mit der Sie eine SSH-Verbindung zur VM-Instanz auf Port 22 herstellen können, indem Sie den folgenden Befehl ausführen:

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

Status des VPN-Tunnels überprüfen

So überprüfen Sie, ob der Tunnel aktiv ist:

Rufen Sie die VPN-Seite in der Google Cloud Console auf.

Weiter zur VPN-Seite
Klicken Sie auf den Tab Google VPN-Tunnel.
Suchen Sie im Feld Status für jeden Tunnel ein grünes Häkchen und das Wort "Etabliert". Wenn diese Elemente vorhanden sind, haben Ihre Gateways einen Tunnel ausgehandelt. Sollte nach ein paar Minuten noch immer kein Häkchen angezeigt werden, lesen Sie den Abschnitt zur Fehlerbehebung.

Weitere Logging-Informationen zu Ihren VPN-Tunneln finden Sie auf der Seite Fehlerbehebung unter VPN-Logs überprüfen. Sie können z. B. Messwerte zu verloren gegangenen Paketen, zum Tunnelstatus und zu empfangenen und gesendeten Byte anzeigen.

Nachdem Sie Cloud VPN nun mit den erforderlichen Gateways, Tunneln und Firewallregeln konfiguriert haben, können Sie eine sichere Verbindung zwischen der "lokalen" VM-Instanz und dem in GKE ausgeführten MLLP-Adapter herstellen.

Bereitstellung in GKE und Cloud VPN kombinieren

Während Sie zuvor in dieser Anleitung den MLLP-Adapter lokal getestet und HL7v2-Nachrichten über eine Nicht-VPN-Verbindung an den MLLP-Adapter gesendet haben, senden Sie jetzt Nachrichten von einer Compute Engine VM über eine sichere Verbindung mit Cloud VPN zum MLLP-Adapter, der in GKE ausgeführt wird. Die Nachrichten werden dann an einen HL7v2-Speicher weitergeleitet.

Bereitstellung neu erstellen

Erstellen Sie zuerst die Bereitstellung in GKE neu, damit der Cluster die Einstellungen verwendet, die Sie unter Cloud VPN konfigurieren konfiguriert haben:

Führen Sie den Befehl gcloud container clusters delete aus, um den von Ihnen erstellten Cluster mllp-adapter zu löschen. Geben Sie den COMPUTE_ZONE-Wert ein, den Sie beim Erstellen des Clusters verwendet haben.
```
gcloud container clusters delete mllp-adapter --zone=COMPUTE_ZONE
```
Führen Sie die Schritte unter MLLP-Adapter in Kubernetes Engine bereitstellen aus. Wenn Sie jedoch den Cluster in GKE erstellen, fügen Sie das cloud-vpn-network-Netzwerk und das Subnetz subnet-us-central-10-0-1 hinzu, die Sie unter Benutzerdefinierte VPN-Netzwerke und Subnetze erstellen erstellt haben.

Achten Sie darauf, dass der Befehl zur Clustererstellung so aussieht:
```
gcloud container clusters create mllp-adapter \
   --zone=COMPUTE_ZONE \
   --service-account=CLIENT_EMAIL \
   --network=cloud-vpn-network \
   --subnetwork=subnet-us-central-10-0-1
```
wobei
- COMPUTE_ZONE ist die Zone, in der Ihr Cluster bereitgestellt wird. Bei der Konfiguration von Cloud VPN im vorherigen Abschnitt haben Sie das „Google Cloud-seitige” Netzwerk auf us-central1 gesetzt. In diesem „Google Cloud-seitigen” Netzwerk wird der GKE-Cluster ausgeführt. Verwenden Sie eine der folgenden Zonen in us-central1: us-central1-c, us-central1-a, us-central1-f, us-central1-b.
  Hinweis: Der GKE-Cluster und das „Google Cloud-seitige” Netzwerk müssen sich in derselben Region befinden, sonst funktioniert das Routing nicht.
- CLIENT_EMAIL ist die Kennung für das Dienstkonto, das Sie verwenden möchten. Sie hat das Format SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.

Neue Compute Engine-VM mit Netzwerkeinstellungen erstellen

Die folgenden Schritte zeigen, wie Sie mit der Google Cloud Console eine Linux-VM-Instanz in Compute Engine erstellen. Im Gegensatz zur von Ihnen erstellten Compute Engine-VM verwendet diese VM die "lokalen" Netzwerkeinstellungen für die Kommunikation mit dem GKE-Cluster über ein VPN.

Console

Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.
Die Seite VM-Instanzen aufrufen
Klicken Sie auf Instanz erstellen.
Wählen Sie eine Region und eine Zone für die Instanz aus, die den "lokalen seitlichen" Netzwerkeinstellungen entspricht: europe-west1 (Belgium) für die Region und europe-west1-b für die Zone.
Klicken Sie im Abschnitt Bootlaufwerk auf Ändern, um mit der Konfiguration des Bootlaufwerks zu beginnen.
Wählen Sie auf dem Tab Öffentliche Images die Version 9 des Debian-Betriebssystems aus.
Klicken Sie auf Auswählen.
Wählen Sie im Abschnitt Identität und API-Zugriff das von Ihnen erstellte Dienstkonto aus.
Wählen Sie im Bereich Firewall die Option HTTP-Traffic zulassen aus.
Erweitern Sie den Abschnitt Verwaltung, Sicherheit, Laufwerke, Netzwerke, einzelne Mandanten.
Geben Sie auf dem Tab Netzwerk unter Netzwerkschnittstellen die Netzwerkdetails für die "lokalen" Netzwerkeinstellungen an:
1. Wählen Sie im Feld Netzwerk die Option on-prem-vpn-network aus.
2. Im Subnetzwerk wählen Sie aus subnet-europe-west-10-0-2 (10.0.2.0/24).
Erstellen klicken, um die Instanz zu erstellen.

Warten Sie, bis die Instanz gestartet ist. Wenn sie bereit ist, wird dies auf der Seite "VM-Instanzen" mit einem grünen Statussymbol angezeigt.

gcloud

Führen Sie zum Erstellen einer Compute-Instanz die Methode gcloud compute instances create mit den folgenden Optionen aus:

Die ZONE, die den "lokalen" Netzwerkeinstellungen entspricht: europe-west1-b für die Zone.
Lassen Sie HTTP-Traffic zu, indem Sie das Tag http-server angeben
Die von Ihnen erstellte 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

Die Ausgabe ähnelt dem folgenden Beispiel:

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

So stellen Sie eine Verbindung zur Instanz her:

Console

Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.
Die Seite VM-Instanzen aufrufen
Klicken Sie in der Liste der VM-Instanzen in der Zeile der von Ihnen erstellten Instanz auf SSH.

gcloud

Führen Sie den Befehl gcloud compute ssh aus, um eine Verbindung zur Instanz herzustellen:

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

Sie haben nun ein Terminalfenster, über das Sie mit Ihrer Linux-Instanz interagieren können.

Installieren Sie im Terminalfenster Netcat:
```
sudo apt install netcat
```
Laden Sie die Datei hl7v2-mllp-sample.txt herunter und speichern Sie sie in der Instanz.
Führen Sie den folgenden Befehl aus, um HL7v2-Nachrichten über den MLLP-Adapter an Ihren HL7v2-Speicher in dem Verzeichnis zu senden, in das Sie die Datei heruntergeladen haben. Verwenden Sie den Wert von LoadBalancer Ingress, der beim Überprüfen des Dienstes angezeigt wurde.
```
echo -n -e "\x0b$(cat hl7v2-mllp-sample.txt)\x1c\x0d" | nc LOAD_BALANCER_INGRESS_IP_ADDRESS 2575
```
Nachdem Sie den Befehl ausgeführt haben, wird die Nachricht über den MLLP-Adapter an Ihren HL7v2-Speicher gesendet. Wenn die Nachricht erfolgreich in den HL7v2-Speicher aufgenommen wurde, gibt der Befehl die folgende Ausgabe zurück:
```
MSA|AA|20150503223000|ILITY|FROM_APP|FROM_FACILITY|20190312162410||ACK|f4c59243-19c2-4373-bea0-39c1b2ba616b|P|2.5
```
Diese Ausgabe gibt an, dass der HL7v2-Speicher mit dem Antworttyp AA (Application Accept) geantwortet hat. Dies bedeutet, dass die Nachricht validiert und erfolgreich aufgenommen wurde.

Führen Sie den Befehl gcloud pubsub subscriptions pull aus, um die im Pub/Sub-Thema veröffentlichte Nachricht anzuzeigen:

gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION

Der Befehl gibt die folgende Ausgabe zur aufgenommenen HL7v2-Nachricht zurück:

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

Sie können auch die Nachrichten in Ihrem HL7v2-Speicher auflisten, um zu sehen, ob die Nachricht hinzugefügt wurde:

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"

Wenn die Anfrage erfolgreich ist, gibt der Server die ID der Nachricht in einem Ressourcenpfad zurück:

{
  "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

Wenn die Anfrage erfolgreich ist, gibt der Server die ID der Nachricht in einem Ressourcenpfad zurück:

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

Nach Abschluss dieses Abschnitts haben Sie den MLLP-Adapter erfolgreich in GKE bereitgestellt und über ein VPN sicher eine HL7v2-Nachricht von einer "lokalen" Instanz über den Adapter und an die Cloud Healthcare API gesendet.

Clean-up

Um zu vermeiden, dass Ihrem Google Cloud-Konto die in dieser Kurzanleitung verwendeten Ressourcen in Rechnung gestellt werden, können Sie die in Google Cloud erstellten Ressourcen bereinigen.

Projekt löschen

So löschen Sie das in dieser Anleitung erstellte Projekt:

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Fehlerbehebung

Adapterfehler

Nach der Bereitstellung des MLLP-Adapters in GKE tritt beim Adapter ein Fehler auf.

Führen Sie die Schritte unter Fehlerbehebung bei bereitgestellten Arbeitslasten aus.

`Connection refused`-Fehler bei der lokalen Ausführung

Beim lokalen Testen des MLLP-Adapters tritt der Fehler Connection refused auf.

Dieser Fehler tritt bei einigen Mac OS-Nutzern auf. Anstatt das Flag --network=host zu verwenden, verwenden Sie -p 2575:2575. Legen Sie außerdem --receiver_ip=0.0.0.0 anstelle von --receiver_ip=127.0.0.0 fest. Der Befehl sollte wie folgt aussehen:

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`-Fehler bei der lokalen Ausführung

Beim lokalen Testen des MLLP-Adapters tritt der Fehler healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials. auf.

Dieser Fehler tritt auf, wenn der Adapter Ihre lokalen ADC-Anmeldedaten nicht finden kann. Sie müssen Standardanmeldedaten für Anwendungen in Ihrer lokalen Umgebung eingerichtet haben.

Authentifizierungsfehler

Falls beim Testen des MLLP-Adapters lokal, der im Rest dieses Abschnitts nicht behandelt wird, ein Authentifizierungsfehler auftritt, führen Sie den Befehl docker run noch einmal aus und fügen Sie den -v ~/.config:/root/.config am Ende des Befehls hinzu, zum Beispiel:

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