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 MMLP (Minimal Lower Layer Protocol).

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

Objectifs

À la fin de ce tutoriel, vous saurez :

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

  • API Cloud Healthcare
  • Google Kubernetes Engine
  • Instance
  • 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 Cloud Platform peuvent bénéficier d'un essai gratuit.

Avant de commencer

Avant de commencer ce tutoriel, familiarisez-vous avec la documentation conceptuelle sur le protocole MMLP (Minimal Lower Layer Protocol) en consultant la page MLLP et l'adaptateur Google Cloud MMLP. La documentation conceptuelle offre une vue d'ensemble du protocole MMLP, de la manière dont les systèmes de soins peuvent envoyer et recevoir des messages depuis et vers l'API Cloud Healthcare via une connexion MLLP, ainsi que les principes de base de la 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 :

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Dans Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Cloud.

    Accéder à la page de sélection du projet

  3. Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activer les API Cloud Healthcare API, Google Kubernetes Engine, Container Registry, and Pub/Sub.

    Activer les API

  5. Attendez que l'API Kubernetes Engine et les services associés soient activés. Cette opération peut prendre plusieurs minutes.

Choisir une interface système

Pour suivre 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 les outils gcloud et kubectl. L'outil gcloud fournit l'interface de ligne de commande principale pour GCP. kubectl fournit l'interface de ligne de commande permettant d'exécuter des commandes sur les clusters GKE.

Si vous préférez utiliser votre interface système locale, vous devez installer le SDK Cloud, qui inclut les outils gcloud et kubectl.

Pour ouvrir Cloud Shell ou configurer votre interface système locale, procédez comme suit:

Cloud Shell

Pour lancer Cloud Shell, procédez comme suit:

  1. Accédez à Google Cloud Console.

    Google Cloud Console

  2. 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.

Interface système locale

Pour installer les outils gcloud et kubectl, procédez comme suit:

  1. Installez et initialisez le SDK Cloud.
  2. Si vous ne testez l'adaptateur que localement, vous n'avez pas besoin d'effectuer d'autres étapes et pouvez passer à 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 vous n'avez pas encore créé d'ensemble de données de l'API Cloud Healthcare, créez-en un en procédant comme suit:

Console

  1. Dans Cloud Console, accédez à la page "Ensembles de données".

    Accéder à la page Ensembles de données

  2. Cliquez sur Créer un ensemble de données.
  3. Choisissez un identifiant d'ensemble de données unique dans votre projet et votre région. Si l'identifiant n'est pas unique, la création de l'ensemble de données échoue.
  4. Choisissez la région où se trouve l'ensemble de données, puis cliquez sur Créer.

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

gcloud

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

L'exemple suivant fonctionne avec la version v1beta1 de l'API Cloud Healthcare.

gcloud beta 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 magasin HL7v2. Pour en savoir plus, consultez la section Configurer les notifications Pub/Sub.

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

Console

  1. Accédez à la page Sujets Pub/Sub" dans Cloud Console.

    Accéder à la page des sujets Pub/Sub

  2. Cliquez sur Créer un sujet.

  3. Entrez un nom de sujet avec l'URI :

    projects/PROJECT_ID/topics/TOPIC_NAME

    PROJECT_ID correspond à votre ID de projet Google Cloud.

  4. 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

  1. Accédez à la page Sujets Pub/Sub dans Cloud Console.

    Accéder à la page des sujets Pub/Sub

  2. Cliquez sur le sujet de votre projet.

  3. Cliquez sur Créer un abonnement.

  4. Entrez un nom d'abonnement :

    projects/PROJECT_ID/subscriptions/SUBSCRIPTION_NAME

  5. Laissez le champ Type de diffusion défini sur Pull, puis 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 magasin HL7v2 configuré avec un sujet Pub/Sub

Créez un magasin HL7v2 et configurez-le avec un sujet Pub/Sub. Pour créer un magasin 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 magasin HL7v2 et pour le sujet Pub/Sub.

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

Commande 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 pour chaque projet.

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

Console

  1. Sur la page Cloud IAM de Cloud Console, vérifiez que le rôle Agent de service de santé apparaît dans la colonne Rôle du compte de service de projet concerné. Le nom du compte est service-PROJECT_NUMBER@gcp-sa-healthcare.iam.gserviceaccount.com. Pour plus d'informations sur la recherche de PROJECT_NUMBER, voir Identifier des projets.

  2. 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.

  3. Cliquez sur Ajouter un autre rôle, puis recherchez le rôle Éditeur Cloud Pub/Sub.

  4. 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 plus d'informations sur la recherche de PROJECT_ID et de PROJECT_NUMBER, consultez la page 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

Il s'agit d'une application conteneurisée qui est 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 MMLP localement

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 destinataire, il reçoit des messages HL7v2 provenant d'une source externe et appelle messages.ingest pour ingérer les messages dans un magasin HL7v2, créant ainsi une notification Pub/Sub. La notification est envoyée aux applications abonnées au sujet Pub/Sub du magasin 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 messages.ingest. Une fois le message créé, une notification Pub/Sub est envoyée à l'adaptateur, qui publie les messages sur 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 MMLP 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, il appelle messages.ingest et ingère le message HL7v2 dans le magasin 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 :

  1. 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 magasin HL7v2.
    • LOCATION est la région où se trouve votre magasin HL7v2.
    • DATASET_ID est l'ID de l'ensemble de données parent de votre magasin HL7v2.
    • HL7V2_STORE_ID est l'ID du magasin 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.
    
  2. Pour poursuivre le test pendant l'exécution de l'adaptateur en tant que processus de premier plan, ouvrez un autre terminal sur votre ordinateur local.

  3. Dans le nouveau terminal, pour installer Netcat, exécutez la commande suivante :

    sudo apt install netcat
    
  4. Téléchargez le fichier hl7v2-mllp-sample.txt et enregistrez-le sur votre ordinateur local.

  5. Pour envoyer le message HL7v2 à l'adaptateur, exécutez la commande suivante dans le répertoire dans lequel vous avez téléchargé le fichier. L'administrateur MLLP écoute votre hôte local sur le port 2575. La commande envoie le message via l'adaptateur MLLP dans votre magasin HL7v2 :

    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 magasin 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 magasin 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.

  6. Vous pouvez également vérifier que le message a bien été envoyé en ouvrant le terminal sur lequel vous avez exécuté l'adaptateur. Le résultat doit ressembler à l'exemple suivant :

     I0000 00:00:00.000000       1 healthapiclient.go:171] Dialing connection to https://healthcare.googleapis.com:443/v1
     I0000 00:00:00.000000       1 mllp_adapter.go:89] Either --pubsub_project_id or --pubsub_subscription is not provided, notifications of the new messages are not read and no outgoing messages will be sent to the target MLLP address.
     I0213 00:00:00.000000       1 healthapiclient.go:190] Sending message of size 319.
     I0213 00:00:00.000000       1 healthapiclient.go:223] Message was successfully sent.
    
  7. Le message est stocké dans votre magasin HL7v2. Vous pouvez donc appeler messages.list pour l'afficher :

    Commande 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 MMLP localement en tant qu'éditeur

Lorsque vous testez l'adaptateur en tant qu'éditeur, 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'administrateur reconnaît automatiquement les messages Pub/Sub envoyés via messages.create et messages.ingest.

Il vous avertit lorsqu'il récupère et envoie des messages Pub/Sub. L'adresse étant un abonné Pub/Sub, elle 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 de l'abonnement Pub/Sub et vérifier séparément que les messages ont été publiés, vous devez créer un deuxième abonnement Pub/Sub attribué au sujet que vous avez créé précédemment. Les messages envoyés au deuxième abonnement ne sont pas confirmés automatiquement par l'adaptateur et sont conservés 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

  1. Accédez à la page Sujets Pub/Sub dans Cloud Console.

    Accéder à la page des sujets Pub/Sub

  2. Cliquez sur le sujet de votre projet. Il s'agit du sujet que vous avez utilisé pour créer l'abonnement initial.

  3. Cliquez sur Créer un abonnement.

  4. Entrez un nom d'abonnement :

    projects/PROJECT_ID/subscriptions/SECOND_SUBSCRIPTION_NAME

    Laissez le type de distribution défini sur Retrait.

  5. 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 :

  1. Installez Netcat :

    sudo apt install netcat
    
  2. Téléchargez le fichier hl7v2-mllp-ack-sample.txt et enregistrez-le sur votre ordinateur local. Le fichier contient un message ACK dont l'adaptateur a besoin en réponse lorsqu'il tente de publier un message.

  3. 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 :

    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 ...
    
  4. Netcat s'exécute en tant que processus de premier plan. Pour poursuivre le test, ouvrez un autre terminal sur votre ordinateur local.

  5. 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 magasin HL7v2.
    • LOCATION est la région où se trouve votre magasin HL7v2.
    • DATASET_ID est l'ID de l'ensemble de données parent de votre magasin HL7v2.
    • HL7V2_STORE_ID est l'ID du magasin 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 a été associé à votre sujet Pub/Sub. L'administrateur 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.

    Après avoir exécuté la commande précédente, l'adaptateur commence à s'exécuter sur votre ordinateur local à l'adresse IP 127.0.0.1 sur le port 2575.

    L'adresse s'exécute en tant que processus de premier plan. Pour poursuivre le test, ouvrez un autre terminal sur votre ordinateur local.

  6. Téléchargez le fichier hl7v2-sample.json et enregistrez-le sur votre ordinateur local. 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 magasin HL7v2 :

    Commande 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 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.
    
  7. Dans le terminal sur lequel vous avez exécuté Netcat, un résultat semblable à l'exemple 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|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.

  8. 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 MLLP pour chaque sujet Pub/Sub afin de publier les messages sur un autre destinataire externe.

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

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

  2. Exécutez la commande suivante :

    Commande 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 l'adaptateur

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

  1. 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
    
  2. Téléchargez 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.

  3. Pour définir le port 2525 pour le premier récepteur, exécutez la commande suivante :

    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 ...
    
  4. 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 magasin HL7v2.
    • LOCATION est la région où se trouve votre magasin HL7v2.
    • DATASET_ID est l'ID de l'ensemble de données parent de votre magasin HL7v2.
    • HL7V2_STORE_ID est l'ID du magasin 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.

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

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

  1. 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
    
  2. Téléchargez 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.

  3. Pour définir le port 2526 pour le deuxième récepteur, exécutez la commande suivante:

    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 ...
    
  4. 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 magasin HL7v2.
    • LOCATION est la région où se trouve votre magasin HL7v2.
    • DATASET_ID est l'ID de l'ensemble de données parent de votre magasin HL7v2.
    • HL7V2_STORE_ID est l'ID du magasin 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'administrateur consomme les messages de cet abonnement et en accuse réception automatiquement.

    Après avoir exécuté cette commande, l'adaptateur commence à s'exécuter sur votre ordinateur local sur l'adresse IP 127.0.0.1:2576. Il publie les nouveaux messages sur le deuxième destinataire externe sur le port 2526.

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:

  1. Téléchargez hl7v2-sample1.json.

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

    Commande 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, 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 où 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:

  1. Ouvrez un nouveau terminal sur votre ordinateur local.

  2. Pour créer un message qui sera publié uniquement auprès du deuxième récepteur externe, téléchargez hl7v2-sample2.json.

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

    Commande 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, 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, 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 la fonction sendFacility est SEND_FACILITY_2. Par conséquent, la notification Pub/Sub n'est envoyée qu'au deuxième sujet Pub/Sub. Après la création du message, le premier adaptateur MLLP ne renvoie aucune réponse, tandis que le second adaptateur MMLP 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 où vous avez exécuté le deuxième 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

Lorsque vous transmettez des messages HL7v2 via 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'administrateur 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 ou d'état d'application dans le cluster ou dans le 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 uniques 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, vous devez suivre le guide de démarrage rapide de GKE pour en savoir plus sur le fonctionnement du produit.

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

Comme indiqué dans la documentation GKE sur l'authentification auprès de 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 aux nœuds créés par GKE. 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 des 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) à partir de pods exécutés sur GKE en mettant à jour les autorisations du compte de service par défaut ou en attribuant davantage de niveaux d'accès 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 pour é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

  1. Dans Cloud Console, accédez à la page Créer une clé de compte de service.

    Accéder à la page Créer une clé de compte de service

  2. Dans la liste Compte de service, sélectionnez Nouveau compte de service.

  3. Dans le champ Nom du compte de service, saisissez un nom.

  4. Dans la liste Rôle, sélectionnez les rôles suivants:

    • Pub/Sub > Abonné Pub/Sub
    • Cloud Healthcare > Ingestion de message HL7v2 Healthcare
  5. Si vous souhaitez activer la surveillance, sélectionnez le rôle supplémentaire suivant:

    • Monitoring > Monitoring Metric Writer (Rédacteur de métriques de surveillance)
  6. Cliquez sur Créer.

gcloud

  1. 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.
    
  2. 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.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
    
  3. Pour créer une clé de compte de service, exécutez la commande gcloud iam service-accounts keys create.

    gcloud iam service-accounts keys create ~/FILENAME.json \
       --iam-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
    

    Une fois le compte de service créé, un fichier de clé JSON contenant les identifiants du compte de service est alors téléchargé sur votre ordinateur. Vous utiliserez ce fichier de clé pour configurer l'adaptateur MLLP afin qu'il s'authentifie auprès des API Cloud Healthcare, Pub/Sub et Cloud Monitoring à l'aide de l'indicateur --service-account pendant la création de cluster.

    created key [e44da1202f82f8f4bdd9d92bc412d1d8a837fa83] of type [json] as
        [/usr/home/USERNAME/FILENAME.json] for
        [SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com]
    

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 vos clusters et leurs ressources résident. 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 cet indicateur remplace la valeur par défaut.
  • CLIENT_EMAIL est l'identifiant du compte de service. Vous trouverez cette adresse e-mail dans le fichier de clé du compte de service, dans le champ "client_email":. Elle a le format 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

Lorsque vous déployez 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 page Créer un déploiement.

  1. Ouvrez un terminal distinct.

  2. À 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=RECEIVER_IP"

où :

  • PROJECT_ID est l'ID du projet Google Cloud contenant votre magasin HL7v2.
  • LOCATION est la région où se trouve votre magasin HL7v2.
  • DATASET_ID est l'ID de l'ensemble de données parent de votre magasin HL7v2.
  • HL7V2_STORE_ID est l'ID du magasin HL7v2 auquel vous envoyez des messages HL7v2.
  • RECEIVER_IP est l'adresse IP du centre de soins d'origine. Si vous effectuez des tests à partir d'une machine locale faisant office de centre de soins, définissez RECEIVER_IP sur 0.0.0.0.

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 rendre l'adaptateur MLLP accessible aux applications extérieures au cluster (centre de soins, par exemple), 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, à condition qu'elles utilisent le même réseau VPC et soient situées dans la même région Google Cloud. Par exemple, pour rendre l'adaptateur accessible à une instance de VM Compute Engine dans la même région et sur le même réseau VPC, vous pouvez ajouter un équilibreur de charge interne à la ressource du service du cluster.

Dans le répertoire où vous avez créé le fichier manifeste de déploiement, utilisez l'éditeur de texte pour créer un fichier manifeste de service appelé mllp_adapter_service.yaml avec le contenu suivant. Ce fichier est responsable de la configuration de 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 ce cas, il s'agit de mllp-adapter-service.
  • metadata: annotations: est une annotation qui spécifie 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 de 2575 est utilisé.
  • ports: targetPort: est utilisé pour spécifier le port sur chaque pod sur lequel le service est exécuté.
  • 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), il peut générer sa propre adresse IP à laquelle vous pouvez envoyer des messages. Pour l'instant, autorisez 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 de GKE.

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

Déployer le déploiement

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

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 utiliser l'outil kubectl pour l'inspecter.

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

Après avoir créé le service, inspectez-le pour vérifier qu'il a bien été configuré.

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

Alors que précédemment dans ce tutoriel, vous avez testé l'adaptateur MLLP localement et envoyé des messages HL7v2 à votre magasin HL7v2, vous allez maintenant envoyer des messages depuis une VM Compute Engine vers l'adaptateur MMLP exécuté sur GKE. Les messages sont ensuite transférés vers un magasin 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 trouverez la liste des notifications publiées dans votre sujet Pub/Sub et les messages HL7v2 de votre magasin HL7v2. L'instance de VM Compute Engine doit disposer d'autorisations 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

  1. Dans Cloud Console, accédez à la page Créer une clé de compte de service.

    Accéder à la page Créer une clé de compte de service

  2. Dans la liste Compte de service, sélectionnez Nouveau compte de service.

  3. Dans le champ Nom du compte de service, saisissez un nom.

  4. Dans la liste Rôle, sélectionnez les deux rôles suivants:

    • Pub/Sub > Abonné Pub/Sub
    • Cloud Healthcare > Consommateur de message HL7v2 Healthcare
  5. Cliquez sur Créer.

Une fois le compte de service créé, un fichier de clé JSON contenant les identifiants du compte de service est alors téléchargé sur votre ordinateur.

gcloud

  1. 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.
    
  2. 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
    
  3. Pour créer une clé de compte de service, exécutez la commande gcloud iam service-accounts keys create.

    gcloud iam service-accounts keys create ~/FILENAME.json \
       --iam-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
    

    Une fois le compte de service créé, un fichier de clé JSON contenant les identifiants du compte de service est alors téléchargé sur votre ordinateur.

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

Console

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

    Accéder à la page Instances de VM

  2. Cliquez sur Créer une instance.

  3. Choisissez une région et une zone pour l'instance correspondant à la zone que vous avez sélectionnée lors de la création du cluster. Par exemple, si vous avez utilisé us-central1-a pour COMPUTE_ZONE lors de la création du cluster, alors sélectionnez us-central1 (Iowa) pour la Région et us-central1-a pour la Zone dans l'écran de création de l'instance.

  4. Dans la section Disque de démarrage, cliquez sur Modifier pour commencer la configuration de votre disque de démarrage.

  5. Dans l'onglet Images publiques, choisissez la version 9 du système d'exploitation Debian.

  6. Cliquez sur Sélectionner.

  7. Dans la section Identité et accès à l'API, sélectionnez le compte de service que vous avez créé.

  8. Dans la section Pare-feu, sélectionnez Autoriser le trafic HTTP.

  9. 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
  • La balise 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-9 \
   --image-project=debian-cloud \
   --tags=http-server \
   --service-account=SERVICE_ACCOUNT

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

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

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

    Accéder à la page Instances de VM

  2. 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.

  1. Dans la fenêtre du terminal, installez Netcat:

    sudo apt install netcat
    
  2. 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.

  3. Pour commencer à envoyer des messages HL7v2 à votre magasin HL7v2 via l'adaptateur MLLP, exécutez la commande suivante dans le répertoire dans lequel vous avez téléchargé le fichier. Utilisez la valeur LoadBalancer Ingress 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é à votre magasin HL7v2 via l'adaptateur MLLP. Si le message a bien été ingéré dans le magasin 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 magasin 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.

  4. 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   |
    └-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘
    
  5. Vous pouvez également répertorier les messages de votre magasin HL7v2 pour voir s'ils ont été ajoutés:

    Commande 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é l'adaptateur MLLP sur GKE et envoyé un message HL7v2 depuis une instance distante via l'adaptateur et vers l'API Cloud Healthcare.

Dans la suite de ce tutoriel, vous allez apprendre à chiffrer en toute sécurité les messages HL7v2 transmis en configurant un VPN entre une instance Compute Engine, qui fait 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 qu'Internet. En utilisant un VPN, vous pouvez envoyer des messages depuis votre centre de soins via l'adaptateur MLLP et vers 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:

Configurer Cloud VPN

Cloud VPN connecte de manière sécurisée votre réseau sur site à votre réseau cloud privé virtuel (VPC) Google Cloud via une connexion VPN IPsec. Le trafic circulant 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 un réseau de 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 dans une région Google Cloud différente.

La passerelle VPN configurée dans us-central1 fait office de passerelle Cloud VPN côté Google Cloud, tandis que la passerelle Cloud VPN dans 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 l'élement 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 s'exécutant 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:

  1. 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
    
  2. 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
    
  3. 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
    
  4. 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:

  1. 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
    
  2. Pour réserver une adresse IP externe (statique) régionale 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
    
  3. Notez les adresses IP externes afin de pouvoir les utiliser pour configurer les passerelles VPN dans la section suivante. Pour récupérer les adresses IP externes, exécutez la commande suivante:

    Adresse IP de 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:

  1. Créez une clé pré-partagée (clé secrète partagée) sécurisée par chiffrement en suivant les instructions de la section Générer une clé pré-partagée forte. Cette clé est référencée sous la forme SHARED_SECRET dans cette section.

  2. Pour créer l'objet 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
    
  3. 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
    
  4. 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 VPN "sur site" notée à 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
    
  5. 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 VPN, le tunnel et la route pour le VPN "sur site":

  1. Pour créer l'objet 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"
    
  2. 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
    
  3. 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
    
  4. 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é.

  1. 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
    
  2. 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
    
  3. Créez une règle de pare-feu qui vous permet de vous connecter en SSH à l'instance de VM sur le port 22 en exécutant 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 votre tunnel est opérationnel, procédez comme suit:

  1. Accédez à la page VPN dans Cloud Console.

    Accéder à la page VPN

  2. Cliquez sur l'onglet tunnels VPN Google.

  3. Dans le champ État de chaque tunnel, recherchez une coche verte et le mot "Établi". Si ces éléments sont présents, vos passerelles ont négocié un tunnel. Si aucune marque n'apparaît après quelques minutes, consultez la section 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 correctement 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

Alors que précédemment dans ce tutoriel, vous avez testé l'adaptateur MLLP localement et envoyé des messages HL7v2 via une connexion non VPN à l'adaptateur MLLP, vous allez maintenant envoyer des messages à partir d'une VM Compute Engine sur une connexion sécurisée utilisant Cloud VPN à l'adaptateur MLLP s'exécutant sur GKE. Les messages sont ensuite transférés vers un magasin 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:

  1. 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
    
  2. Suivez les étapes de la section Déployer l'adaptateur MLLP sur 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 VPN personnalisés.

    Assurez-vous que la commande de création de 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é GCP" pour utiliser us-central1. C'est sur ce réseau "côté GCP" que le cluster GKE s'exécute. Utilisez l'une des zones suivantes dans us-central1: us-central1-c, us-central1-a, us-central1-f, us-central1-b.

    • CLIENT_EMAIL est l'identifiant du compte de service. Vous le trouverez dans le fichier de clé de compte de service dans le champ "client_email":. Il a le format SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.

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

Les étapes suivantes montrent comment créer une instance de machine virtuelle Linux dans Compute Engine à l'aide de Cloud Console. 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

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

    Accéder à la page Instances de VM

  2. Cliquez sur Créer une instance.

  3. 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.

  4. Dans la section Disque de démarrage, cliquez sur Modifier pour commencer à configurer le disque de démarrage.

  5. Dans l'onglet Images publiques, choisissez la version 9 du système d'exploitation Debian.

  6. Cliquez sur Sélectionner.

  7. Dans la section Identité et accès à l'API, sélectionnez le compte de service que vous avez créé.

  8. Dans la section Pare-feu, sélectionnez Autoriser le trafic HTTP.

  9. Développez la section Gestion, sécurité, disques, mise en réseau et location unique.

  10. 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).
  11. 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 la balise http-server
  • Le SERVICE_ACCOUNT que vous avez créé
gcloud compute instances create COMPUTE_NAME \
   --project=PROJECT_ID
   --zone=ZONE
   --image-family=debian-9 \
   --tags=http-server,https-server
   --service-account=SERVICE_ACCOUNT

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

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

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

    Accéder à la page Instances de VM

  2. 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.

  1. Dans la fenêtre du terminal, installez Netcat:

    sudo apt install netcat
    
  2. Téléchargez le fichier hl7v2-mllp-sample.txt et enregistrez-le dans l'instance.

  3. Pour commencer à envoyer des messages HL7v2 à votre magasin HL7v2 via l'adaptateur MLLP, exécutez la commande suivante dans le répertoire dans lequel vous avez téléchargé le fichier. Utilisez la valeur LoadBalancer Ingress 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é à votre magasin HL7v2 via l'adaptateur MLLP. Si le message a bien été ingéré dans le magasin 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 magasin 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.

  4. 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   |
    └-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘
    
  5. Vous pouvez également répertorier les messages de votre magasin HL7v2 pour voir s'ils ont été ajoutés:

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

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer .
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Dépannage

Échecs de l'adaptateur

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

Erreur Connection refused lors de l'exécution locale

Lorsque vous testez l'adaptateur MLLP localement, le message d'erreur Connection refused s'affiche.

  • Cette erreur se produit avec certains utilisateurs de Mac OS. Au lieu d'utiliser l'indicateur --network=host, utilisez -p 2575:2575. Au lieu de définir --receiver_ip=127.0.0.0, définissez --receiver_ip=0.0.0.0. La commande doit se présenter comme suit:

    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 could not find default credentials lors de l'exécution locale

Lorsque vous testez l'adaptateur MLLP localement, le message d'erreur healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials. See https://developers.google.com/accounts/docs/application-default-credentials for more information. s'affiche.

Cette erreur se produit lorsque l'adaptateur ne trouve pas vos identifiants Google Cloud. Pour corriger l'erreur, essayez l'une des méthodes suivantes avant d'exécuter à nouveau la commande: