Cette page a été traduite par l'API Cloud Translation.

Transmettre les messages HL7v2 via des connexions TCP/IP

Ce tutoriel fournit des instructions pour transmettre des messages HL7v2 via des connexions TCP/IP à l'aide du protocole MLLP (Minimal Lower Layer Protocol). Pour exiger que l'image MLLP soit signée par un certificateur, suivez les étapes décrites dans la section Transmettre des messages HL7v2 via des connexions TCP/IP à l'aide d'une image MLL signée.

Ce tutoriel fournit des instructions sur l'exécution de l'adaptateur MLLP Open Source hébergé dans GitHub dans les environnements suivants:

En local/sur site
Dans un conteneur sur GKE avec Cloud VPN
Dans un conteneur sur GKE sans Cloud VPN

Objectifs

À la fin de ce tutoriel, vous saurez :

créer et configurer en local l'adaptateur MLLP avec l'API Cloud Healthcare, et tester l'envoi de messages HL7v2 dans un datastore HL7v2 ;
déployer l'adaptateur MLLP sur GKE et envoyer des messages HL7v2 à partir d'une instance de VM Compute Engine ;
configurer un VPN qui sécurise la connexion entre une instance "sur site" et l'adaptateur MLLP, et envoyer des messages HL7v2 à partir de l'instance "sur site".

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

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

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

Avant de commencer ce tutoriel, nous vous recommandons de vous familiariser avec la documentation conceptuelle sur le protocole MLLP (Minimal Lower Layer Protocol) en consultant la page Protocole MLLP et adaptateur MLLP de Google Cloud. La documentation conceptuelle présente le protocole MLLP, explique comment les systèmes de soins peuvent envoyer et recevoir des messages depuis et vers l'API Cloud Healthcare via une connexion MLLP, et fournit les principes de base du protocole MLLP en matière de sécurité.

Avant de pouvoir configurer l'adaptateur MLLP, vous devez choisir ou créer un projet Google Cloud et activer les API requises en procédant comme suit :

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

Patientez le temps de l'activation de l'API Kubernetes Engine et des services associés. Cette opération peut prendre plusieurs minutes.

Choisir une interface système

Pour réaliser ce tutoriel, vous pouvez utiliser Cloud Shell ou votre interface système locale.

Cloud Shell est un environnement shell permettant de gérer les ressources hébergées sur Google Cloud. Cloud Shell est préinstallé avec la CLI gcloud et l'outil kubectl. gcloud CLI fournit l'interface de ligne de commande principale pour Google Cloud. kubectl : fournit une interface de ligne de commande permettant d'exécuter des commandes sur des clusters GKE.

Si vous préférez utiliser votre shell local, vous devez installer gcloud CLI.

Pour ouvrir Cloud Shell ou configurer votre shell local, procédez comme suit :

Cloud Shell

Pour lancer Cloud Shell, procédez comme suit :

Accédez à Google Cloud Console.

Google Cloud Console
Dans le coin supérieur droit de la console, cliquez sur le bouton Activer Google Cloud Shell .

Une session Cloud Shell s'ouvre dans un cadre en bas de la console. Cette interface système vous permet d'exécuter les commandes gcloud et kubectl.

Shell local

Pour installer gcloud CLI et l'outil kubectl, procédez comme suit :

Installez et initialisez 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.
Si vous testez l'adaptateur en local uniquement, vous n'avez pas besoin d'effectuer d'autres étapes et pouvez passer directement à la section Créer un ensemble de données. Si vous déployez l'adaptateur sur GKE, installez l'outil de ligne de commande kubectl en exécutant la commande suivante :
```
gcloud components install kubectl
```

Créer un ensemble de données

Si ce n'est pas déjà fait, créez un ensemble de données pour l'API Cloud Healthcare en procédant comme suit :

Console

Dans la console Google Cloud, accédez à la page Ensembles de données.
Accéder à la page "Ensembles de données"
Cliquez sur Créer un ensemble de données.
Dans le champ Nom, saisissez un identifiant pour l'ensemble de données. L'ID de l'ensemble de données doit comporter les éléments suivants :
- ID unique dans l'emplacement
- Chaîne Unicode de 1 à 256 caractères composée des éléments suivants :
  - Chiffres
  - Lettres
  - Traits de soulignement
  - Tirets
  - Points
Dans la section Type d'emplacement, sélectionnez l'un des types d'emplacements suivants :
- Région : l'ensemble de données réside de façon permanente dans une région Google Cloud. Après avoir sélectionné cette option, saisissez ou sélectionnez l'emplacement dans le champ Région.
- Multirégional : l'ensemble de données réside de façon permanente dans un emplacement qui couvre plusieurs régions Google Cloud. Après avoir sélectionné cette option, saisissez ou sélectionnez l'emplacement multirégional dans le champ Multirégional.
Cliquez sur Créer.

Le nouvel ensemble de données apparaît dans la liste des ensembles de données.

gcloud

Pour créer un ensemble de données, exécutez la commande gcloud healthcare datasets create :

gcloud healthcare datasets create DATASET_ID \
    --location=LOCATION

Si la requête aboutit, la commande renvoie le résultat suivant :

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

Créer un sujet et un abonnement Pub/Sub

Pour recevoir des notifications lorsque des messages sont créés ou ingérés, vous devez configurer un sujet Pub/Sub avec votre datastore HL7v2. Pour en savoir plus, consultez la page Configurer les notifications Pub/Sub.

Pour créer un sujet, procédez comme suit :

Console

Accédez à la page des Sujets Pub/Sub dans la console Google Cloud.

Accéder à la page des sujets Pub/Sub
Cliquez sur Créer un sujet.
Entrez un nom de sujet avec l'URI :

projects/PROJECT_ID/topics/TOPIC_NAME

où PROJECT_ID correspond à votre ID de projet Google Cloud.
Cliquez sur Créer.

gcloud

Pour créer un sujet, exécutez la commande gcloud pubsub topics create :

gcloud pubsub topics create projects/PROJECT_ID/topics/TOPIC_NAME

Si la requête aboutit, la commande renvoie le résultat suivant :

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

Pour créer un abonnement, procédez comme suit :

Console

Accédez à la page des Sujets Pub/Sub dans la console Google Cloud.

Accéder à la page des sujets Pub/Sub
Cliquez sur le sujet de votre projet.
Cliquez sur Créer un abonnement.
Entrez un nom d'abonnement :

projects/PROJECT_ID/subscriptions/SUBSCRIPTION_NAME
Le champ Type de distribution doit rester défini sur Pull. Cliquez sur Créer.

gcloud

Pour créer un abonnement, exécutez la commande gcloud pubsub subscriptions create :

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

Si la requête aboutit, la commande renvoie le résultat suivant :

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

Créer un datastore HL7v2 configuré avec un sujet Pub/Sub

Créez un datastore HL7v2 et configurez-le avec un sujet Pub/Sub. Pour créer un datastore HL7v2, vous devez déjà avoir créé un ensemble de données. Pour les besoins de ce tutoriel, utilisez le même projet pour votre datastore HL7v2 et pour le sujet Pub/Sub.

Pour créer un datastore HL7v2 configuré avec un sujet Pub/Sub, procédez comme suit :

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"

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

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

PowerShell

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

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

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

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

Configurer les autorisations Pub/Sub

Pour envoyer des notifications à Pub/Sub lorsqu'un message HL7v2 est créé ou ingéré, vous devez configurer les autorisations Pub/Sub sur l'API Cloud Healthcare. Cette étape doit être effectuée une fois par projet.

Pour ajouter le rôle pubsub.publisher requis au compte de service de votre projet, procédez comme suit :

Console

Sur la page Cloud IAM de la console Google Cloud, vérifiez que le rôle Agent de service Healthcare apparaît dans la colonne Rôle pour le compte de service du projet concerné. Le nom du compte est service-PROJECT_NUMBER@gcp-sa-healthcare.iam.gserviceaccount.com. Pour savoir comment trouver l'PROJECT_NUMBER, consultez la section Identifier des projets.
Dans la colonne Héritage correspondant au rôle, cliquez sur l'icône en forme de crayon. Le volet Modifier les autorisations s'affiche.
Cliquez sur Ajouter un autre rôle, puis recherchez le rôle Éditeur Cloud Pub/Sub.
Sélectionnez le rôle, puis cliquez sur Enregistrer. Le rôle pubsub.publisher est ajouté au compte de service.

gcloud

Pour ajouter les autorisations de compte de service, exécutez la commande gcloud projects add-iam-policy-binding. Pour savoir comment rechercher un ID de projet (PROJECT_ID) et un numéro de projet (PROJECT_NUMBER), consultez la section Identifier des projets.

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

Extraire l'image Docker prédéfinie

L'adaptateur MLLP est une application en conteneur stockée dans une image Docker prédéfinie dans Container Registry.

Pour extraire la dernière version de l'image, exécutez la commande suivante :

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

Tester l'adaptateur MLLP en local

Lorsque vous testez l'adaptateur en local, vous pouvez le configurer pour qu'il s'exécute en tant que récepteur, éditeur ou les deux. Les configurations du destinataire et de l'éditeur présentent les principales différences suivantes :

Lorsque l'adaptateur s'exécute en tant que récepteur, il reçoit des messages HL7v2 provenant d'une source externe et appelle messages.ingest pour ingérer les messages dans un datastore HL7v2, créant ainsi une notification Pub/Sub. La notification est envoyée aux applications abonnées au sujet Pub/Sub du datastore HL7v2.
Lorsque l'adaptateur s'exécute en tant qu'éditeur, il écoute les messages HL7v2 créés ou ingérés dans un magasin HL7v2 à l'aide de messages.create ou de messages.ingest. Une fois le message créé, une notification Pub/Sub est envoyée à l'adaptateur et celui-ci publie les messages dans un récepteur externe.

Les sections suivantes montrent comment exécuter l'adaptateur pour qu'il agisse en tant que récepteur ou éditeur.

Après avoir vérifié que vous pouvez exécuter l'adaptateur MLLP sur votre ordinateur local, vous pouvez passer à la section suivante sur le Déploiement de l'adaptateur MLLP sur Google Kubernetes Engine.

Tester l'adaptateur MLLP en local en tant que récepteur

Lorsque l'adaptateur reçoit un message HL7v2 provenant d'une source externe, telle qu'un centre de soins, l'adaptateur appelle messages.ingest et ingère le message HL7v2 dans le datastore HL7v2 configuré. Vous pouvez observer cela dans le code source de l'adaptateur.

Pour tester l'adaptateur en local en tant que récepteur, procédez comme suit :

Sur la machine sur laquelle vous avez extrait l'image Docker préconfigurée, exécutez la commande suivante :
```
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
```
où :
- PROJECT_ID est l'ID du projet Google Cloud contenant votre datastore HL7v2.
- LOCATION est la région où se trouve votre datastore HL7v2.
- DATASET_ID est l'ID de l'ensemble de données parent de votre datastore HL7v2.
- HL7V2_STORE_ID est l'ID du datastore HL7v2 auquel vous envoyez des messages HL7v2.
Après avoir exécuté la commande précédente, l'adaptateur imprime un message semblable au suivant et commence à s'exécuter sur votre ordinateur local à l'adresse IP 127.0.0.1 sur le port 2575 :
```
I0000 00:00:00.000000      1 healthapiclient.go:171] Dialing connection to https://healthcare.googleapis.com:443/v1
I0000 00:00:00.000000      1 mllp_adapter.go:89] Either --pubsub_project_id or --pubsub_subscription is not provided, notifications of the new messages are not read and no outgoing messages will be sent to the target MLLP address.
```
Si vous rencontrez des problèmes, procédez comme suit :
- Si vous utilisez macOS et que la commande précédente échoue avec l'erreur Connection refused, consultez la section Erreur "Connexion refusée" lors de l'exécution en local.
- Si la commande précédente échoue avec l'erreur healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials. See https://developers.google.com/accounts/docs/application-default-credentials for more information., consultez la section Erreur could not find default credentials lors de l'exécution en local.
- Si vous rencontrez d'autres erreurs d'authentification, consultez la page Erreurs d'authentification.
Pour poursuivre les tests pendant que l'adaptateur s'exécute en tant que processus de premier plan, ouvrez un autre terminal sur votre machine locale.
Dans le nouveau terminal, pour installer Netcat, exécutez la commande suivante :
```
sudo apt install netcat
```
Téléchargez le fichier hl7v2-mllp-sample.txt et enregistrez-le sur votre machine locale.
Pour envoyer le message HL7v2 à l'adaptateur, exécutez la commande suivante dans le répertoire où vous avez téléchargé le fichier. L'adaptateur MLLP écoute sur l'hôte local sur le port 2575. La commande envoie le message via l'adaptateur MLLP dans votre magasin HL7v2.
Linux
```
echo -n -e "\x0b$(cat hl7v2-mllp-sample.txt)\x1c\x0d" | nc -q1 localhost 2575 | less
```
Si le message a bien été ingéré dans le datastore HL7v2, la commande renvoie le résultat suivant :
```
^KMSH|^~\&|TO_APP|TO_FACILITY|FROM_APP|FROM_FACILITY|19700101010000||ACK|c507a97e-438d-44b0-b236-ea95e5ecbbfb|P|2.5^MMSA|AA|20150503223000^\
```
Ce résultat indique que le datastore HL7v2 a répondu avec un type de réponse AA (Application Accept), ce qui signifie que le message a été validé et ingéré avec succès.

Vous pouvez également vérifier que le message a bien été envoyé en ouvrant le terminal dans lequel vous avez exécuté l'adaptateur. Le résultat doit se présenter sous la forme suivante :

 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.

Le message est stocké dans votre datastore HL7v2. Vous pouvez donc appeler messages.list pour l'afficher :

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"

Si la requête aboutit, le serveur renvoie l'ID du message dans un chemin de ressource :

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

Si la requête aboutit, le serveur renvoie l'ID du message dans un chemin de ressource :

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

Tester l'adaptateur MLLP en local en tant qu'émetteur

Lorsque vous testez l'adaptateur en tant qu'émetteur, vous pouvez créer des messages en appelant messages.create ou messages.ingest et en fournissant un fichier de message sous forme de données binaires.

L'adaptateur accuse automatiquement réception des messages Pub/Sub envoyés via messages.create et messages.ingest.

L'adaptateur vous avertit lorsqu'il récupère et envoie des messages Pub/Sub. L'adaptateur étant un abonné Pub/Sub, il accuse automatiquement réception de ces messages. Par conséquent, ils sont supprimés de la file d'attente de messages de l'abonnement Pub/Sub que vous avez configuré avec l'adaptateur.

Pour extraire des messages de l'abonnement Pub/Sub et vérifier qu'ils ont été publiés, vous devez créer un deuxième abonnement Pub/Sub attribué au sujet que vous avez créé précédemment. L'adaptateur n'accuse pas automatiquement réception des messages envoyés au deuxième abonnement et les conserve pour que vous puissiez les extraire.

Pour créer un deuxième abonnement Pub/Sub attribué au sujet que vous avez créé précédemment, procédez comme suit :

Console

Accédez à la page des Sujets Pub/Sub dans la console Google Cloud.

Accéder à la page des sujets Pub/Sub
Cliquez sur le sujet de votre projet. Il s'agit du sujet que vous avez utilisé pour créer l'abonnement initial.
Cliquez sur Créer un abonnement.
Entrez un nom d'abonnement :

projects/PROJECT_ID/subscriptions/SECOND_SUBSCRIPTION_NAME

Laissez le type de distribution défini sur Retrait.
Cliquez sur Créer.

gcloud

Pour créer un deuxième abonnement Pub/Sub attribué au sujet que vous avez créé précédemment, exécutez la commande gcloud pubsub subscriptions create :

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

Si la requête aboutit, la commande renvoie le résultat suivant :

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

Pour tester l'adaptateur en local en tant qu'éditeur, procédez comme suit sur la machine sur laquelle vous avez extrait l'image Docker préconfigurée :

Installez Netcat :
```
sudo apt install netcat
```
Téléchargez le fichier hl7v2-mllp-ack-sample.txt et enregistrez-le sur votre machine locale. Le fichier contient un message ACK requis par l'adaptateur en tant que réponse lorsqu'il tente de publier un message.
Pour que Netcat écoute les connexions entrantes sur le port 2525, exécutez la commande suivante dans le répertoire dans lequel vous avez téléchargé le fichier.
Linux
```
echo -n -e "\x0b$(cat hl7v2-mllp-ack-sample.txt)\x1c\x0d" | nc -q1 -lv -p 2525 | less
```
Après le démarrage de Netcat, un message de sortie semblable à l'exemple suivant s'affiche :
```
listening on [any] 2525 ...
```
Netcat s'exécute en tant que processus de premier plan. Pour poursuivre le test, ouvrez un autre terminal sur votre ordinateur local.
Pour démarrer l'adaptateur, exécutez la commande suivante dans le nouveau terminal :
```
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
```
où :
- PROJECT_ID est l'ID du projet Google Cloud contenant votre datastore HL7v2.
- LOCATION est la région où se trouve votre datastore HL7v2.
- DATASET_ID est l'ID de l'ensemble de données parent de votre datastore HL7v2.
- HL7V2_STORE_ID est l'ID du datastore HL7v2 auquel vous envoyez des messages HL7v2.
- PROJECT_ID est l'ID du projet Google Cloud contenant le sujet Pub/Sub.
- PUBSUB_SUBSCRIPTION correspond au nom du premier abonnement que vous avez créé et qui a été associé à votre sujet Pub/Sub. L'adaptateur utilise les messages de cet abonnement et en accuse automatiquement réception. Par conséquent, pour afficher les messages publiés sur le sujet, vous devez extraire les messages du deuxième abonnement que vous avez créé précédemment.
Une fois cette commande exécutée, l'adaptateur commence à s'exécuter sur votre machine locale sur l'adresse IP 127.0.0.1 et le port 2575.

Si vous rencontrez des problèmes, procédez comme suit :
- Si vous utilisez macOS et que la commande précédente échoue avec l'erreur Connection refused, consultez la section Erreur "Connexion refusée" lors de l'exécution en local.
- Si la commande précédente échoue avec l'erreur healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials. See https://developers.google.com/accounts/docs/application-default-credentials for more information., consultez la section Erreur could not find default credentials lors de l'exécution en local.
- Si vous rencontrez d'autres erreurs d'authentification, consultez la page Erreurs d'authentification.
L'adaptateur s'exécute en tant que processus de premier plan. Pour poursuivre le test, ouvrez un autre terminal sur votre machine locale.

Téléchargez le fichier hl7v2-sample.json et enregistrez-le sur votre machine locale. Dans le répertoire où vous avez téléchargé le fichier, appelez la méthode messages.create pour créer le message dans un datastore HL7v2 :

curl

Pour créer un message HL7v2, envoyez une requête POST et spécifiez les informations suivantes :

Le nom de l'ensemble de données parent
Le nom du magasin HL7v2
Un message
Un jeton d'accès

L'exemple suivant montre une requête POST utilisant curl et un exemple de fichier JSON appelé 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"

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

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

PowerShell

Pour créer un message HL7v2, envoyez une requête POST et spécifiez les informations suivantes :

Le nom de l'ensemble de données parent
Le nom du magasin HL7v2
Un message
Un jeton d'accès

L'exemple suivant montre une requête POST utilisant Windows PowerShell et un exemple de fichier JSON appelé 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

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

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

Une fois le message créé, l'adaptateur MLLP renvoie une réponse semblable à la suivante:

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.

Dans le terminal à partir duquel vous avez exécuté Netcat, vous obtenez un résultat semblable à ce qui suit. Ce résultat indique que le message a été publié :
```
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^\
```
Cela correspond à la valeur du champ data de la réponse que vous avez reçue lors de la création du message. Elle est identique à la valeur data du fichier hl7v2-sample.json.

Pour afficher le message publié par l'adaptateur dans le sujet Pub/Sub, exécutez la commande gcloud pubsub subscriptions pull sur le deuxième abonnement Pub/Sub que vous avez créé :

gcloud pubsub subscriptions pull --auto-ack SECOND_SUBSCRIPTION

La commande renvoie le résultat suivant concernant le message HL7v2 créé : Notez la valeur publish=true dans la colonne ATTRIBUTES, qui indique que le message a été publié dans Pub/Sub :

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

Publier des messages sur différents récepteurs externes

Vous pouvez configurer le magasin HL7v2 avec plusieurs sujets Pub/Sub et utiliser des filtres pour envoyer des notifications à différents sujets Pub/Sub. Vous pouvez ensuite exécuter un adaptateur MMLP pour chaque sujet Pub/Sub afin de publier les messages dans un autre récepteur externe.

Pour configurer le datastore HL7v2 avec plusieurs sujets Pub/Sub et un filtre pour chaque sujet, procédez comme suit :

Créez deux sujets Pub/Sub et un abonnement pour chaque sujet. Pour en savoir plus, consultez la section Créer un sujet et un abonnement Pub/Sub.

Exécutez la commande suivante :

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"

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

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

PowerShell

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

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

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

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

Tester le routage des messages

Pour tester le routage des messages, procédez comme suit :

Configurer et démarrer le premier récepteur et le premier adaptateur

Pour configurer et démarrer le premier récepteur et le premier adaptateur, procédez comme suit :

Sur la machine sur laquelle vous avez extrait l'image Docker préconfigurée, exécutez la commande suivante pour installer Netcat :
```
sudo apt install netcat
```
Téléchargez le fichier hl7v2-mllp-ack-sample.txt, si ce n'est pas déjà fait. Le fichier contient un message ACK utilisé comme réponse par l'adaptateur lorsqu'il tente de publier un message.
Pour définir le port 2525 pour le premier récepteur, exécutez la commande suivante :
Linux
```
echo -n -e "\x0b$(cat hl7v2-mllp-ack-sample.txt)\x1c\x0d" | nc -q1 -lv -p 2525 | less
```
Lorsque le processus Netcat démarre, le résultat suivant s'affiche :
```
listening on [any] 2525 ...
```
Pour démarrer le premier adaptateur, exécutez la commande suivante dans un nouveau terminal :
```
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
```
où :
- PROJECT_ID est l'ID du projet Google Cloud contenant votre datastore HL7v2.
- LOCATION est la région où se trouve votre datastore HL7v2.
- DATASET_ID est l'ID de l'ensemble de données parent de votre datastore HL7v2.
- HL7V2_STORE_ID est l'ID du datastore HL7v2 auquel vous envoyez des messages HL7v2.
- PROJECT_ID est l'ID du projet Google Cloud contenant le sujet Pub/Sub.
- PUBSUB_SUBSCRIPTION est le nom du premier abonnement que vous avez créé et qui est associé à votre premier sujet Pub/Sub. L'administrateur utilise les messages de cet abonnement et en accuse réception automatiquement.
Une fois cette commande exécutée, l'adaptateur commence à s'exécuter sur votre ordinateur local sur l'adresse IP 127.0.0.1:2575. Il publie les nouveaux messages sur le premier récepteur externe sur le port 2525.

Important : Si vous utilisez macOS et que cette commande échoue avec l'erreur Connection refused, consultez la section Erreur "Connexion refusée" lors de l'exécution en local. Si cette commande échoue avec l'erreur could not find default credentials, consultez la section Erreur could not find default credentials lors de l'exécution en local.

Configurer et démarrer le deuxième récepteur et le deuxième adaptateur

Pour configurer et démarrer le deuxième récepteur et le deuxième adaptateur, procédez comme suit :

Sur la machine sur laquelle vous avez extrait l'image Docker préconfigurée, exécutez la commande suivante pour installer Netcat :
```
sudo apt install netcat
```
Téléchargez le fichier hl7v2-mllp-ack-sample.txt, si ce n'est pas déjà fait. Le fichier contient un message ACK utilisé comme réponse par l'adaptateur lorsqu'il tente de publier un message.
Pour définir le port 2526 pour le deuxième récepteur, exécutez la commande suivante.
Linux
```
echo -n -e "\x0b$(cat hl7v2-mllp-ack-sample.txt)\x1c\x0d" | nc -q1 -lv -p 2526 | less
```
Lorsque le processus Netcat démarre, le résultat suivant s'affiche :
```
listening on [any] 2526 ...
```
Pour démarrer le deuxième adaptateur, exécutez la commande suivante dans un nouveau terminal :
```
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
```
où :
- PROJECT_ID est l'ID du projet Google Cloud contenant votre datastore HL7v2.
- LOCATION est la région où se trouve votre datastore HL7v2.
- DATASET_ID est l'ID de l'ensemble de données parent de votre datastore HL7v2.
- HL7V2_STORE_ID est l'ID du datastore HL7v2 auquel vous envoyez des messages HL7v2.
- PROJECT_ID est l'ID du projet Google Cloud contenant le sujet Pub/Sub.
- SECOND_PUBSUB_SUBSCRIPTION est le nom du deuxième abonnement que vous avez créé et qui est associé à votre deuxième sujet Pub/Sub. L'adaptateur utilise les messages de cet abonnement et en accuse réception automatiquement.
Une fois cette commande exécutée, l'adaptateur commence à s'exécuter sur votre ordinateur local sur l'adresse IP 127.0.0.1 et le port 2576. Il publie les nouveaux messages sur le deuxième récepteur externe sur le port 2526.

Important : Si vous utilisez macOS et que cette commande échoue avec l'erreur Connection refused, consultez la section Erreur "Connexion refusée" lors de l'exécution en local. Si cette commande échoue avec l'erreur could not find default credentials., consultez la section Erreur could not find default credentials lors de l'exécution en local.

Publier un message auprès du premier récepteur

Pour créer un message qui ne sera publié que sur le premier récepteur externe, procédez comme suit :

Téléchargez hl7v2-sample1.json.

Dans le répertoire où vous avez téléchargé hl7v2-sample1.json, appelez la méthode messages.create pour créer le message dans un datastore HL7v2 :

curl

Pour créer un message HL7v2, envoyez une requête POST et spécifiez les informations suivantes :

Le nom de l'ensemble de données parent
Le nom du magasin HL7v2
Un message
Un jeton d'accès

L'exemple suivant montre une requête POST utilisant curl et un exemple de fichier JSON appelé 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"

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

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

PowerShell

Pour créer un message HL7v2, envoyez une requête POST et spécifiez les informations suivantes :

Le nom de l'ensemble de données parent
Le nom du magasin HL7v2
Un message
Un jeton d'accès

L'exemple suivant montre une requête POST utilisant Windows PowerShell et un exemple de fichier JSON appelé 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

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

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

Dans cette réponse, sendFacility est défini sur SEND_FACILITY_1. Par conséquent, la notification Pub/Sub n'est envoyée qu'au premier sujet Pub/Sub. Une fois le message créé, le premier adaptateur MLLP renvoie la réponse suivante :

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.

Le deuxième adaptateur MLLP ne renvoie aucune réponse, car aucune notification n'est envoyée au deuxième sujet Pub/Sub.

Dans le terminal à partir duquel vous avez exécuté le premier processus Netcat, le résultat suivant s'affiche. Ce résultat indique que le message a été publié :

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

Ce résultat correspond à la valeur du champ data de la réponse que vous avez reçue lors de la création du message. Elle est identique à la valeur data du fichier hl7v2-sample1.json.

Publier un message auprès du deuxième récepteur

Pour créer un message qui sera publié uniquement auprès du deuxième récepteur externe, procédez comme suit :

Ouvrez un nouveau terminal sur votre machine locale.
Pour créer un message qui sera publié uniquement auprès du deuxième récepteur externe, téléchargez hl7v2-sample2.json.

Dans le répertoire où vous avez téléchargé hl7v2-sample2.json, appelez la méthode messages.create pour créer le message dans un datastore HL7v2 :

curl

Pour créer un message HL7v2, envoyez une requête POST et spécifiez les informations suivantes :

Le nom de l'ensemble de données parent
Le nom du magasin HL7v2
Un message
Un jeton d'accès

L'exemple suivant montre une requête POST utilisant curl et un exemple de fichier JSON appelé 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"

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

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

PowerShell

Pour créer un message HL7v2, envoyez une requête POST et spécifiez les informations suivantes :

Le nom de l'ensemble de données parent
Le nom du magasin HL7v2
Un message
Un jeton d'accès

L'exemple suivant montre une requête POST utilisant Windows PowerShell et un exemple de fichier JSON appelé 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

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

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

Notez que le paramètre sendFacility (Installation d'envoi) est défini sur SEND_FACILITY_2. Par conséquent, la notification Pub/Sub n'est envoyée qu'au deuxième sujet Pub/Sub. Une fois le message créé, le premier adaptateur MLLP ne renvoie aucune réponse, tandis que le deuxième adaptateur MLLP renvoie la réponse suivante :

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.

Dans le terminal à partir duquel vous avez exécuté le premier processus Netcat, le résultat suivant s'affiche. Ce résultat indique que le message a été publié :

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

Ce résultat correspond à la valeur du champ data de la réponse que vous avez reçue lors de la création du message. Elle est identique à la valeur data du fichier hl7v2-sample2.json.

Déployer l'adaptateur MLLP sur Google Kubernetes Engine

Lors de la transmission de messages HL7v2 au protocole MLLP depuis votre centre de soins, une configuration possible consiste à envoyer les messages à un adaptateur déployé dans Google Cloud et à les transférer à l'API Cloud Healthcare.

L'adaptateur MLLP s'exécute en tant qu'application sans état sur un cluster GKE. Un cluster GKE est un groupe géré d'instances de VM permettant d'exécuter des applications en conteneur. Les applications sans état sont des applications qui ne stockent pas de données ni d'état d'application dans le cluster ou dans l'espace de stockage persistant. Au lieu de cela, les données et l'état de l'application sont conservés par le client, ce qui rend les applications sans état plus évolutives.

GKE utilise le contrôleur Déploiement pour déployer des applications sans état en tant que pods uniformes et non uniques. Les déploiements gèrent l'état souhaité de l'application : nombre de pods devant exécuter l'application, version de l'image de conteneur à exécuter, étiquettes des pods, etc. L'état souhaité peut être modifié de manière dynamique par le biais de mises à jour de la spécification de pod du déploiement.

En même temps que vous déployez l'adaptateur, vous créez un contrôleur de Service qui vous permet de connecter l'adaptateur à l'API Cloud Healthcare à l'aide d'un équilibrage de charge interne.

Si vous débutez avec GKE, nous vous recommandons de suivre le guide de démarrage rapide de GKE pour comprendre le fonctionnement du produit.

Ajouter des autorisations d'API Pub/Sub au compte de service GKE

Comme indiqué dans la documentation GKE sur la page S'authentifier sur Cloud Platform avec des comptes de service, chaque nœud d'un cluster de conteneurs est une instance Compute Engine. Par conséquent, lorsque l'adaptateur MLLP s'exécute sur un cluster de conteneurs, il hérite automatiquement des champs d'application des instances Compute Engine sur lesquelles il est déployé.

Google Cloud crée automatiquement un compte de service nommé "Compte de service Compute Engine par défaut", et GKE associe ce compte de service à ses propres nœuds. Selon la configuration de votre projet, le compte de service par défaut peut disposer ou non des autorisations nécessaires pour utiliser d'autres API Cloud Platform. GKE attribue également certains champs d'application d'accès limités aux instances Compute Engine.

Pour de meilleurs résultats, ne vous authentifiez pas auprès d'autres services Google Cloud (tels que Pub/Sub) depuis les pods exécutés sur GKE en mettant à jour les autorisations du compte de service par défaut ou en attribuant d'autres champs d'application d'accès supplémentaires aux instances Compute Engine. Créez plutôt vos propres comptes de service.

Vous devez accorder les autorisations Pub/Sub nécessaires au cluster de conteneurs, mais vous avez également la possibilité d'accorder des autorisations visant à écrire des métriques dans Cloud Monitoring.

Pour créer un compte de service ne contenant que les champs d'application requis par le cluster de conteneurs, procédez comme suit :

Console

Créez un compte de service :

Dans la console Google Cloud, accédez à la page Créer un compte de service.

Accéder à la page "Créer un compte de service"
Sélectionnez un projet.
Dans le champ Nom du compte de service, saisissez un nom. Google Cloud Console remplit le champ ID du compte de service en fonction de ce nom.

Facultatif : Dans le champ Description du compte de service, saisissez une description.
Cliquez sur Create (Créer).
Cliquez sur le champ Sélectionner un rôle.

Sous Tous les rôles, cliquez sur Pub/Sub > Abonné Pub/Sub.
Cliquez sur Ajouter un autre rôle, puis sur le champ Sélectionner un rôle.

Sous Tous les rôles, cliquez sur Cloud Healthcare > Ingestion de message HL7v2 Healthcare.
Facultatif : Si vous souhaitez activer la surveillance, cliquez sur Ajouter un autre rôle, puis sur le champ Sélectionner un rôle.

Sous Tous les rôles, cliquez sur Surveillance > Rédacteur de métriques Monitoring.
Cliquez sur Continuer.
Cliquez sur OK pour terminer la création du compte de service.

Ne fermez pas la fenêtre de votre navigateur. Vous l'utiliserez dans la procédure suivante.

gcloud

Pour créer le compte de service, exécutez la commande gcloud iam service-accounts create.
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
La sortie confirme la création du compte de service :
```
Created service account SERVICE_ACCOUNT_NAME.
```

Pour attribuer chaque rôle au compte de service, exécutez la commande gcloud projects add-iam-policy-binding.

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

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

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

Le résultat inclut la stratégie mise à jour :

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

Créer le cluster

Pour créer le cluster dans GKE, exécutez la commande gcloud container clusters create :

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

où :

COMPUTE_ZONE est la zone dans laquelle votre cluster est déployé. Une zone est un emplacement régional approximatif dans lequel résident vos clusters et leurs ressources. Par exemple, us-west1-a est une zone de la région us-west. Si vous avez défini une zone par défaut à l'aide de gcloud config set compute/zone, la valeur de cette option remplace la valeur par défaut.
CLIENT_EMAIL correspond à l'identifiant du compte de service que vous souhaitez utiliser. Son format est le suivant : SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.

La commande renvoie un résultat semblable à l'exemple suivant :

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

Après avoir créé le cluster, GKE crée trois instances de VM Compute Engine. Vous pouvez vérifier cela en répertoriant les instances à l'aide de la commande suivante :

gcloud compute instances list

Configurer le déploiement

Lors du déploiement d'une application sur GKE, vous définissez les propriétés du déploiement à l'aide d'un fichier manifeste de déploiement, qui est généralement un fichier YAML. Pour obtenir un exemple, consultez la section Créer un déploiement.

Ouvrez un terminal distinct.
À l'aide d'un éditeur de texte, créez un fichier manifeste de déploiement appelé mllp_adapter.yaml avec le contenu suivant :

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"

où :

PROJECT_ID est l'ID du projet Google Cloud contenant votre datastore HL7v2.
LOCATION est la région où se trouve votre datastore HL7v2.
DATASET_ID est l'ID de l'ensemble de données parent de votre datastore HL7v2.
HL7V2_STORE_ID est l'ID du datastore HL7v2 auquel vous envoyez des messages HL7v2.

Le déploiement possède les propriétés suivantes :

spec: replicas: est le nombre de pods répliqués gérés par le déploiement.
spec: template: metadata: labels: est l'étiquette attribuée à chaque pod, grâce à laquelle le déploiement gère les pods.
spec: template: spec: est la spécification de pod, qui définit le fonctionnement de chaque pod.
spec: containers inclut le nom du conteneur à exécuter dans chaque pod et l'image de conteneur à exécuter.

Pour en savoir plus sur les spécifications de déploiement, consultez la documentation de référence sur l'API de déploiement.

Configurer le service

Pour permettre aux applications extérieures au cluster (telles qu'un centre de soins) d'accéder à l'adaptateur MLLP, vous devez configurer un équilibreur de charge interne.

Si vous n'avez pas configuré de VPN, les applications peuvent accéder à l'adaptateur MLLP via l'équilibreur de charge interne tant qu'elles utilisent le même réseau VPC et sont situées dans la même région Google Cloud. Par exemple, pour qu'une instance de VM Compute Engine de la même région et sur le même réseau VPC puisse accéder à l'adaptateur, vous pouvez ajouter un équilibreur de charge interne à la ressource Service du cluster.

Dans le répertoire dans lequel vous avez créé le fichier manifeste de déploiement, utilisez l'éditeur de texte pour créer un fichier manifeste de service nommé mllp_adapter_service.yaml avec le contenu suivant. Ce fichier sert à configurer l'équilibrage de charge interne :

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

Le service possède les propriétés suivantes :

metadata: name: est le nom choisi pour le service. Dans le cas présent, il s'agit de mllp-adapter-service.
metadata: annotations: est une annotation qui indique qu'un équilibreur de charge interne doit être configuré.
spec: type: est le type d'équilibreur de charge.
ports: port: permet de spécifier le port sur lequel le service peut recevoir du trafic provenant d'autres services du même cluster. Le port MLLP par défaut 2575 est utilisé.
ports: targetPort: permet de spécifier le port sur chaque pod exécutant le service.
spec: selector: app: spécifie les pods ciblés par le service.

Bien qu'il soit possible de spécifier une adresse IP pour l'équilibreur de charge (à l'aide du champ clusterIP), l'équilibreur de charge peut générer sa propre adresse IP à laquelle vous pouvez envoyer des messages. Pour le moment, laissez le cluster générer l'adresse IP, que vous utiliserez plus tard dans ce tutoriel.

Pour en savoir plus sur l'équilibrage de charge interne, consultez la documentation GKE.

Pour en savoir plus sur la spécification de l'objet Service, consultez la documentation de référence de l'API Service.

Déployer le déploiement

Pour déployer l'adaptateur sur un cluster GKE, exécutez la commande suivante dans le répertoire contenant le fichier manifeste de déploiement mllp_adapter.yaml :

kubectl apply -f mllp_adapter.yaml

La commande renvoie le résultat suivant :

deployment.extensions "mllp-adapter-deployment" created

Inspecter le déploiement

Une fois le déploiement créé, vous pouvez l'inspecter à l'aide de l'outil kubectl.

Pour obtenir des informations détaillées sur le déploiement, exécutez la commande suivante :

kubectl describe deployment mllp-adapter

Pour répertorier le pod créé par le déploiement, exécutez la commande suivante :

kubectl get pods -l app=mllp-adapter

Pour obtenir des informations sur le pod créé :

kubectl describe pod POD_NAME

Si le déploiement a réussi, la dernière partie du résultat de la commande précédente doit contenir les informations suivantes :

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

Déployer le service et créer l'équilibreur de charge interne

Pour créer l'équilibreur de charge interne, exécutez la commande suivante dans le répertoire contenant le fichier manifeste du service mllp_adapter_service.yaml :

kubectl apply -f mllp_adapter_service.yaml

La commande renvoie le résultat suivant :

service "mllp-adapter-service" created

Inspecter le service

Une fois le service créé, inspectez-le pour vérifier qu'il a été configuré correctement.

Pour inspecter l'équilibreur de charge interne, exécutez la commande suivante :

kubectl describe service mllp-adapter-service

Le résultat de la commande est semblable à l'exemple suivant :

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

Le remplissage de l'adresse IP LoadBalancer Ingress peut prendre jusqu'à une minute. Vous utiliserez cette adresse IP et le port 2575 pour accéder au service en dehors du cluster à l'étape suivante.

Créer une VM Compute Engine et envoyer des messages

Précédemment dans ce tutoriel, vous avez testé l'adaptateur MLLP en local et envoyé des messages HL7v2 à votre datastore HL7v2. Vous allez désormais envoyer des messages depuis une VM Compute Engine à l'adaptateur MLLP exécuté sur GKE. Les messages sont ensuite transférés vers un datastore HL7v2.

Pour envoyer des requêtes de la nouvelle instance au cluster GKE, l'instance et les instances existantes doivent se trouver dans la même région et utiliser le même réseau VPC.

À la fin de cette section, vous répertorierez les notifications publiées dans votre sujet Pub/Sub et les messages HL7v2 de votre datastore HL7v2. Vous devez accorder des autorisations à l'instance de VM Compute Engine pour effectuer ces tâches. Avant de créer l'instance, créez un compte de service avec les autorisations requises en procédant comme suit :

Console

Créez un compte de service :

Dans la console Google Cloud, accédez à la page Créer un compte de service.

Accéder à la page "Créer un compte de service"
Sélectionnez un projet.
Dans le champ Nom du compte de service, saisissez un nom. Google Cloud Console remplit le champ ID du compte de service en fonction de ce nom.

Facultatif : Dans le champ Description du compte de service, saisissez une description.
Cliquez sur Create (Créer).
Cliquez sur le champ Sélectionner un rôle.

Sous Tous les rôles, cliquez sur Pub/Sub > Abonné Pub/Sub.
Cliquez sur Ajouter un autre rôle, puis sur le champ Sélectionner un rôle.

Sous Tous les rôles, cliquez sur Cloud Healthcare > Consommateur de message HL7v2 Healthcare.
Cliquez sur Continuer.
Cliquez sur OK pour terminer la création du compte de service.

Ne fermez pas la fenêtre de votre navigateur. Vous l'utiliserez dans la procédure suivante.

gcloud

Pour créer le compte de service, exécutez la commande gcloud iam service-accounts create.
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
La sortie confirme la création du compte de service :
```
Created service account SERVICE_ACCOUNT_NAME.
```

Pour attribuer chaque rôle au compte de service, exécutez la commande gcloud projects add-iam-policy-binding.

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

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

Le résultat inclut la stratégie mise à jour :

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

Les étapes suivantes montrent comment créer une instance de VM Linux dans Compute Engine :

Console

Dans Google Cloud Console, accédez à la page Instances de VM.

Accéder à la page Instances de VM
Cliquez sur Créer une instance.
Choisissez une région et une zone pour l'instance. Celle-ci doit correspondre à la zone que vous avez sélectionnée lors de la création du cluster. Par exemple, si vous avez défini COMPUTE_ZONE sur us-central1-a lors de la création du cluster, sélectionnez us-central1 (Iowa) pour la région et us-central1-a pour la zone sur l'écran de création de l'instance.
Dans la section Disque de démarrage, cliquez sur Modifier pour commencer la configuration de votre disque de démarrage.
Dans l'onglet Images publiques, choisissez la version 9 du système d'exploitation Debian.
Cliquez sur Sélectionner.
Dans la section Identité et accès à l'API, sélectionnez le compte de service que vous avez créé.
Dans la section Pare-feu, sélectionnez Autoriser le trafic HTTP.
Cliquez sur Créer pour créer l'instance.

gcloud

Pour créer une instance de calcul, exécutez la méthode gcloud compute instances create avec les options suivantes :

La ZONE que vous avez sélectionné lors de la création du cluster
Le tag http-server pour autoriser le trafic HTTP
Le SERVICE_ACCOUNT que vous avez créé

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

Le résultat ressemble à ce qui suit :

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

Patientez un court instant le temps que l'instance démarre. Une fois l'instance démarrée, elle est répertoriée sur la page "Instances de VM" avec une icône d'état verte.

Par défaut, l'instance utilise le même réseau VPC par défaut que le cluster, ce qui signifie que le trafic peut être envoyé de l'instance au cluster.

Pour vous connecter à l'instance, procédez comme suit :

Console

Dans Google Cloud Console, accédez à la page Instances de VM.
Accéder à la page Instances de VM
Dans la liste des instances de machine virtuelle, cliquez sur SSH sur la ligne de l'instance que vous avez créée.

gcloud

Pour vous connecter à l'instance, exécutez la commande gcloud compute ssh :

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

Vous disposez maintenant d'une fenêtre de terminal pour interagir avec votre instance Linux.

Dans la fenêtre du terminal, installez Netcat :
```
sudo apt install netcat
```
Téléchargez le fichier hl7v2-mllp-sample.txt et enregistrez-le dans l'instance. Pour en savoir plus sur l'encodage et les terminateurs de segment utilisés dans le fichier, consultez la section Séparateurs de segment de message HL7v2 et encodage.
Pour commencer à envoyer des messages HL7v2 via l'adaptateur MLLP à votre datastore HL7v2, exécutez la commande suivante dans le répertoire où vous avez téléchargé le fichier. Utilisez la valeur LoadBalancer Ingress qui était affichée lorsque vous avez inspecté le service.
```
echo -n -e "\x0b$(cat hl7v2-mllp-sample.txt)\x1c\x0d" | nc LOAD_BALANCER_INGRESS_IP_ADDRESS 2575
```
Une fois la commande exécutée, le message est envoyé via l'adaptateur MLLP à votre datastore HL7v2. Si le message a bien été ingéré dans le datastore HL7v2, la commande renvoie le résultat suivant :
```
MSA|AA|20150503223000|ILITY|FROM_APP|FROM_FACILITY|20190312162410||ACK|f4c59243-19c2-4373-bea0-39c1b2ba616b|P|2.5
```
Ce résultat indique que le datastore HL7v2 a répondu avec un type de réponse AA (Application Accept), ce qui signifie que le message a été validé et ingéré avec succès.

Pour afficher le message publié dans le sujet Pub/Sub, exécutez la commande gcloud pubsub subscriptions pull :

gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION

La commande renvoie le résultat suivant concernant le message HL7v2 ingéré :

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

Vous pouvez également répertorier les messages de votre datastore HL7v2 pour voir s'ils ont été ajoutés :

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"

Si la requête aboutit, le serveur renvoie l'ID du message dans un chemin de ressource :

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

Si la requête aboutit, le serveur renvoie l'ID du message dans un chemin de ressource :

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

À la fin de cette section, vous avez déployé avec succès l'adaptateur MLLP sur GKE, et envoyé un message HL7v2 à partir d'une instance distante via l'adaptateur et vers l'API Cloud Healthcare.

Dans la suite de ce tutoriel, vous allez apprendre à chiffrer de manière sécurisée les messages HL7v2 transmis, en configurant un VPN entre une instance Compute Engine faisant office d'instance "sur site" et l'adaptateur.

Configurer un VPN

L'utilisation d'un VPN vous permet d'étendre le réseau privé sur lequel vous envoyez des messages HL7v2 sur un réseau public, tel que Internet. En utilisant un VPN, vous pouvez envoyer des messages depuis votre centre de soins via l'adaptateur MLLP et Google Cloud. Les systèmes de ce flux fonctionnent comme s'ils se trouvaient sur un seul réseau privé.

Il existe deux méthodes pour sécuriser votre connexion MLLP à l'aide d'un VPN :

Utiliser Cloud VPN
Utiliser la solution VPN de bout en bout Strongswan de Docker

Configurer Cloud VPN

Cloud VPN connecte de manière sécurisée votre réseau sur site à votre réseau VPC (cloud privé virtuel) Google Cloud via une connexion VPN IPsec. Le trafic échangé entre les deux réseaux est chiffré par une passerelle VPN, puis déchiffré par l'autre passerelle VPN. Cela permet de protéger vos données lorsqu'elles transitent sur Internet ou sur le réseau d'un centre de soins.

Dans ce tutoriel, chaque passerelle VPN que vous configurez se trouve sur un réseau et un sous-réseau personnalisés différents et dans une région Google Cloud différente.

La passerelle VPN configurée dans la région us-central1 sert de passerelle Cloud VPN du côté de Google Cloud, tandis que la passerelle Cloud VPN de la région europe-west1 simule votre passerelle "sur site".

Informations de référence sur les noms et les adresses

À titre indicatif, ce tutoriel utilise les noms et adresses IP suivants :

Côté Google Cloud

Nom du réseau : cloud-vpn-network
Nom du sous-réseau : subnet-us-central-10-0-1
Région : us-central1
Plage de sous-réseaux : 10.0.1.0/24
Nom de l'adresse IP externe : cloud-vpn-ip
Nom de passerelle VPN : vpn-us-central
Nom du tunnel VPN : vpn-us-central-tunnel-1

Côté sur site

Nom du réseau : on-prem-vpn-network
Nom du sous-réseau : subnet-europe-west-10-0-2
Région : europe-west1
Plage de sous-réseaux : 10.0.2.0/24
Nom de l'adresse IP externe : on-prem-vpn-ip
Nom de passerelle VPN : vpn-europe-west
Nom du tunnel VPN : vpn-europe-west-tunnel-1

Créer des réseaux et des sous-réseaux VPC personnalisés

La première étape de la configuration de Cloud VPN consiste à créer deux réseaux VPC. Un réseau, appelé on-prem-vpn-network, est configuré dans l'environnement sur site et s'exécute sur une instance de VM Compute Engine appelée on-prem-instance. L'autre réseau, appelé cloud-vpn-network, est celui utilisé par le cluster GKE qui exécute l'adaptateur MLLP. Vous vous connecterez à la VM on-prem-instance et enverrez des messages HL7v2 à l'adaptateur MLLP exécuté sur le réseau cloud-vpn-network via son équilibreur de charge interne.

Créez deux réseaux VPC personnalisés et leurs sous-réseaux en procédant comme suit :

Pour créer le premier réseau VPC cloud-vpn-network, exécutez la commande suivante :

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

Pour créer le sous-réseau subnet-us-central-10-0-1 pour le réseau cloud-vpn-network, exécutez la commande suivante :

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

Pour créer le réseau VPC on-prem-vpn-network, exécutez la commande suivante :

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

Pour créer le sous-réseau subnet-europe-west-10-0-2 pour le réseau VPC on-prem-vpn-network, exécutez la commande suivante :

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

Créer une adresse IP externe

Avant de créer les passerelles VPN, réservez une adresse IP externe pour chaque passerelle en procédant comme suit :

Pour réserver une adresse IP externe (statique) régionale pour l'adresse cloud-vpn-ip, exécutez la commande suivante :
```
gcloud compute addresses create cloud-vpn-ip \
   --project=PROJECT_ID \
   --region=us-central1
```
Pour réserver une adresse IP externe régionale (statique) pour l'adresse on-prem-vpn-ip, exécutez la commande suivante :
```
gcloud compute addresses create on-prem-vpn-ip \
   --project=PROJECT_ID \
   --region=europe-west1
```

Notez les adresses IP externes, car elles vous serviront à configurer les passerelles VPN dans la section suivante. Pour récupérer les adresses IP externes, exécutez la commande suivante :

Adresse IP Cloud VPN :

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

Adresse IP du VPN "sur site" :

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

Les commandes renvoient un résultat semblable à celui-ci :

address: 203.0.113.1

Créer les passerelles, les tunnels et les routes VPN

Pour créer la passerelle, le tunnel et la route VPN pour le Cloud VPN, procédez comme suit :

Créez une clé pré-partagée (clé secrète partagée) sécurisée de manière cryptographique en suivant les instructions de la page Générer une clé pré-partagée sécurisée. Cette clé est référencée sous le nom SHARED_SECRET (clé secrète partagée) dans cette section.

Pour créer la passerelle VPN cible, exécutez la commande suivante :

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

Pour créer trois règles de transfert, exécutez les commandes suivantes en remplaçant la variable CLOUD_VPN_EXTERNAL_ADDRESS par la valeur de l'adresse IP Cloud VPN de la section précédente :

Envoyer le trafic ESP (IPsec) à la passerelle :

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

Envoyer le trafic UDP 500 à la passerelle :

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

Envoyer le trafic UDP 4500 à la passerelle :

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

Pour créer un tunnel dans la passerelle Cloud VPN, exécutez la commande suivante. Remplacez ON_PREM_VPN_IP par la valeur de l'adresse IP du réseau sur site obtenue dans la section précédente.

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

Pour créer une route statique vers 10.0.2.0/24, exécutez la commande suivante :

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"

Procédez comme suit pour créer la passerelle, le tunnel et la route pour le VPN "sur site" :

Pour créer la passerelle VPN cible, exécutez la commande suivante :

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

Pour créer trois règles de transfert, exécutez les commandes suivantes en remplaçant la variable ON_PREMISES_VPN_EXTERNAL_ADDRESS par la valeur de l'adresse IP VPN "sur site" de la section précédente :

Envoyer le trafic ESP (IPsec) à la passerelle :

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

Envoyer le trafic UDP 500 à la passerelle :

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

Envoyer le trafic UDP 4500 à la passerelle :

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

Pour créer un tunnel dans la passerelle "sur site", exécutez la commande suivante :

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

Pour créer une route statique vers 10.0.1.0/24, exécutez la commande suivante :

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"

Vous avez créé les passerelles Cloud VPN et "sur site" et démarré leurs tunnels. Les passerelles VPN ne se connecteront pas tant que vous n'aurez pas créé de règles de pare-feu pour autoriser le trafic dans le tunnel qui les relie.

Créer des règles de pare-feu

Vous devez créer des règles de pare-feu pour les deux côtés du tunnel VPN. Ces règles permettent à l'ensemble du trafic TCP, UDP et ICMP provenant du sous-réseau situé d'un côté du tunnel VPN d'être acheminé vers l'autre côté.

Pour créer les règles de pare-feu pour le sous-réseau Cloud VPN, exécutez la commande suivante :

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

Pour créer les règles de pare-feu pour le sous-réseau "sur site", exécutez la commande suivante :

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

Pour créer une règle de pare-feu qui vous permet de vous connecter en SSH à l'instance de VM sur le port 22, exécutez la commande suivante :

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

Vérifier l'état du tunnel VPN

Pour vérifier que le tunnel est opérationnel, procédez comme suit :

Accédez à la page VPN dans la console Google Cloud.

Accéder à la page VPN
Cliquez sur l'onglet Tunnels VPN Google.
Dans le champ État de chaque tunnel, recherchez une coche verte et la mention "Établi". Si elles sont présentes, vos passerelles ont négocié un tunnel. Si elles ne sont toujours pas affichées après quelques minutes, consultez la page Dépannage.

Pour obtenir d'autres informations de journalisation relatives aux tunnels VPN, consultez la section Vérifier les journaux VPN de la page Dépannage. Par exemple, vous pouvez afficher des métriques relatives aux paquets supprimés, à l'état du tunnel ainsi qu'aux octets reçus et envoyés.

Maintenant que vous avez configuré Cloud VPN avec les passerelles, les tunnels et les règles de pare-feu nécessaires, vous pouvez créer une connexion sécurisée entre l'instance de VM "sur site" et l'adaptateur MLLP exécuté sur GKE.

Combiner le déploiement sur GKE et Cloud VPN

Précédemment dans ce tutoriel, vous avez testé l'adaptateur MLLP en local et envoyé des messages HL7v2 à l'adaptateur MLLP via une connexion non-VPN. Vous allez désormais envoyer des messages depuis une VM Compute Engine à l'adaptateur MLLP exécuté sur GKE à l'aide de Cloud VPN via une connexion sécurisée. Les messages sont ensuite transférés vers un datastore HL7v2.

Recréer le déploiement

Tout d'abord, recréez le déploiement sur GKE afin que le cluster utilise les paramètres que vous avez configurés dans la section Configurer Cloud VPN :

Pour supprimer le cluster mllp-adapter que vous avez créé, exécutez la commande gcloud container clusters delete. Saisissez la valeur COMPUTE_ZONE que vous avez utilisée lors de la création du cluster.
```
gcloud container clusters delete mllp-adapter --zone=COMPUTE_ZONE
```
Suivez les étapes de la section Déployer l'adaptateur MLLP sur Google Kubernetes Engine. Mais, lorsque vous créez le cluster dans GKE, ajoutez le réseau cloud-vpn-network et le sous-réseau subnet-us-central-10-0-1 que vous avez créés dans la section Créer des réseaux et des sous-réseaux VPC personnalisés.

Assurez-vous que la commande de création du cluster ressemble à ceci :
```
gcloud container clusters create mllp-adapter \
   --zone=COMPUTE_ZONE \
   --service-account=CLIENT_EMAIL \
   --network=cloud-vpn-network \
   --subnetwork=subnet-us-central-10-0-1
```
où :
- COMPUTE_ZONE est la zone dans laquelle votre cluster est déployé. Lorsque vous avez configuré Cloud VPN dans la section précédente, vous avez défini le réseau "côté Google Cloud" de manière à utiliser us-central1. C'est sur ce réseau "côté Google Cloud" que le cluster GKE s'exécute. Utilisez l'une des zones suivantes de us-central1 : us-central1-c, us-central1-a, us-central1-f ou us-central1-b.
  Remarque : Le cluster GKE et le réseau "côté Google Cloud" doivent se trouver dans la même région, sinon le routage ne fonctionnera pas.
- CLIENT_EMAIL correspond à l'identifiant du compte de service que vous souhaitez utiliser. Son format est le suivant : SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.

Créer une VM Compute Engine avec les paramètres réseau

Les étapes suivantes montrent comment créer une instance de machine virtuelle Linux dans Compute Engine à l'aide de la console Google Cloud. Contrairement à la VM Compute Engine que vous avez créée, cette VM utilise les paramètres réseau "sur site" pour communiquer. avec le cluster GKE via un VPN.

Console

Dans Google Cloud Console, accédez à la page Instances de VM.
Accéder à la page Instances de VM
Cliquez sur Créer une instance.
Choisissez un Région et une Zone pour l'instance qui correspond aux paramètres réseau du côté "sur site" : europe-west1 (Belgium) pour la Région et europe-west1-b pour la Zone.
Dans la section Disque de démarrage, cliquez sur Modifier pour commencer à configurer le disque de démarrage.
Dans l'onglet Images publiques, choisissez la version 9 du système d'exploitation Debian.
Cliquez sur Sélectionner.
Dans la section Identité et accès à l'API, sélectionnez le compte de service que vous avez créé.
Dans la section Pare-feu, sélectionnez Autoriser le trafic HTTP.
Développez la section Gestion, sécurité, disques, mise en réseau et location unique.
Sous Interfaces réseau dans l'onglet Réseau, spécifiez les détails du réseau pour les paramètres réseau du côté "sur site" :
1. Dans le champ Réseau, sélectionnez on-prem-vpn-network.
2. Dans le champ Sous-réseau, sélectionnez subnet-europe-west-10-0-2 (10.0.2.0/24).
Cliquez sur Créer pour créer l'instance.

Patientez un court instant le temps que l'instance démarre. Lorsqu'elle est prête, elle est répertoriée sur la page Instances de VM avec une icône d'état verte.

gcloud

Pour créer une instance de calcul, exécutez la méthode gcloud compute instances create avec les options suivantes :

ZONE qui correspond aux paramètres réseau du côté "sur site" : europe-west1-b pour la zone.
Autoriser le trafic HTTP en spécifiant le tag http-server
Le SERVICE_ACCOUNT que vous avez créé

gcloud compute instances create COMPUTE_NAME \
   --project=PROJECT_ID
   --zone=ZONE
   --image-family=debian-10 \
   --tags=http-server,https-server
   --service-account=SERVICE_ACCOUNT

Le résultat ressemble à ce qui suit :

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

Pour vous connecter à l'instance, procédez comme suit :

Console

Dans Google Cloud Console, accédez à la page Instances de VM.
Accéder à la page Instances de VM
Dans la liste des instances de machine virtuelle, cliquez sur SSH sur la ligne de l'instance que vous avez créée.

gcloud

Pour vous connecter à l'instance, exécutez la commande gcloud compute ssh :

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

Vous disposez maintenant d'une fenêtre de terminal pour interagir avec votre instance Linux.

Dans la fenêtre du terminal, installez Netcat :
```
sudo apt install netcat
```
Téléchargez le fichier hl7v2-mllp-sample.txt et enregistrez-le dans l'instance.
Pour commencer à envoyer des messages HL7v2 via l'adaptateur MLLP à votre datastore HL7v2, exécutez la commande suivante dans le répertoire où vous avez téléchargé le fichier. Utilisez la valeur LoadBalancer Ingress qui était affichée lorsque vous avez inspecté le service.
```
echo -n -e "\x0b$(cat hl7v2-mllp-sample.txt)\x1c\x0d" | nc LOAD_BALANCER_INGRESS_IP_ADDRESS 2575
```
Une fois la commande exécutée, le message est envoyé via l'adaptateur MLLP à votre datastore HL7v2. Si le message a bien été ingéré dans le datastore HL7v2, la commande renvoie le résultat suivant :
```
MSA|AA|20150503223000|ILITY|FROM_APP|FROM_FACILITY|20190312162410||ACK|f4c59243-19c2-4373-bea0-39c1b2ba616b|P|2.5
```
Ce résultat indique que le datastore HL7v2 a répondu avec un type de réponse AA (Application Accept), ce qui signifie que le message a été validé et ingéré avec succès.

Pour afficher le message publié dans le sujet Pub/Sub, exécutez la commande gcloud pubsub subscriptions pull :

gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION

La commande renvoie le résultat suivant concernant le message HL7v2 ingéré :

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

Vous pouvez également répertorier les messages de votre datastore HL7v2 pour voir s'ils ont été ajoutés :

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"

Si la requête aboutit, le serveur renvoie l'ID du message dans un chemin de ressource :

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

Si la requête aboutit, le serveur renvoie l'ID du message dans un chemin de ressource :

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

Une fois cette section terminée, vous avez déployé avec succès l'adaptateur MLLP sur GKE via un VPN, et envoyé un message HL7v2 de manière sécurisée à partir d'une instance "sur site" via l'adaptateur et vers l'API Cloud Healthcare.

Nettoyer

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud, vous pouvez nettoyer les ressources créées sur Google Cloud.

Supprimer le projet

Pour supprimer le projet que vous avez créé dans ce tutoriel, procédez comme suit :

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

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.

Dépannage

Échecs de l'adaptateur

Une fois l'adaptateur déployé sur GKE, une erreur se produit.

Suivez la procédure décrite dans la section Résoudre les problèmes liés aux charges de travail déployées.

Erreur "Connexion refusée" (`Connection refused`) lors de l'exécution en local

Lorsque vous testez l'adaptateur MLLP en local, vous rencontrez l'erreur Connection refused.

Cette erreur se produit avec certains utilisateurs de macOS. Au lieu d'utiliser l'option --network=host, utilisez -p 2575:2575. De même, au lieu de définir --receiver_ip=127.0.0.0, définissez --receiver_ip=0.0.0.0. La commande devrait se présenter comme suit :

Remarque : Lorsque vous indiquez une valeur pour --pubsub_subscription, saisissez uniquement le nom de l'abonnement. Ne saisissez pas l'URI complet. Par exemple, si l'URI de votre abonnement est projects/my-projects/subscriptions/my-subscription, indiquez uniquement my-subscription.
```
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
```

Erreur "Connexion refusée" (`could not find default credentials`) lors de l'exécution en local

Lorsque vous testez l'adaptateur MLLP en local, vous rencontrez l'erreur healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials..

Cette erreur se produit lorsque l'adaptateur ne trouve pas vos identifiants ADC locaux. Assurez-vous d'avoir configuré les Identifiants par défaut de l'application dans votre environnement local.

Erreurs d'authentification

Si vous rencontrez des erreurs d'authentification lorsque vous testez l'adaptateur MLLP en local qui ne sont pas abordées dans le reste de cette section, réexécutez la commande docker run et ajoutez l'option -v ~/.config:/root/.config à la fin de la commande, comme illustré ci-dessous :

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