Trasmissione di messaggi HL7v2 su connessioni TCP/IP

Questo tutorial fornisce istruzioni per la trasmissione di messaggi HL7v2 su connessioni TCP/IP utilizzando il protocollo MLLP (Minor Layer Protocol) minimo. Per richiedere che l'immagine MLLP sia firmata da un attestatore, segui i passaggi descritti in Trasmettere messaggi HL7v2 su connessioni TCP/IP tramite un'immagine MLLP firmata.

Questo tutorial fornisce istruzioni per eseguire l'adattatore MLLP open source ospitato in GitHub nei seguenti ambienti:

Obiettivi

Una volta completato questo tutorial, saprai come:

Costi

Questo tutorial utilizza i seguenti componenti fatturabili di Google Cloud:

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

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono beneficiare di una prova gratuita.

Prima di iniziare

Prima di iniziare questo tutorial, acquisisci familiarità con la documentazione concettuale sul protocollo MLLP (Minor Layer Protocol) minimo esaminando l'adattatore MLLP e Google Cloud. La documentazione concettuale offre una panoramica di MLLP, come i sistemi di assistenza possono inviare e ricevere messaggi da e verso l'API Cloud Healthcare su una connessione MLLP e le nozioni di base sulla sicurezza di MLLP.

Prima di poter configurare l'adattatore MLLP, devi scegliere o creare un progetto Google Cloud e abilitare le API richieste completando i seguenti passaggi:

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
  2. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  4. Abilita le API Cloud Healthcare API, Google Kubernetes Engine, Container Registry, and Pub/Sub.

    Abilita le API

  5. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  6. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  7. Abilita le API Cloud Healthcare API, Google Kubernetes Engine, Container Registry, and Pub/Sub.

    Abilita le API

  8. Attendi l'attivazione dell'API Kubernetes Engine e dei servizi correlati. L'operazione potrebbe richiedere diversi minuti.

Scelta di una shell

Per completare questo tutorial, puoi utilizzare Cloud Shell o la tua shell locale.

Cloud Shell è un ambiente shell per la gestione delle risorse in hosting su Google Cloud. Cloud Shell include l'interfaccia a riga di comando gcloud e lo strumento kubectl. L'interfaccia a riga di comando gcloud fornisce l'interfaccia a riga di comando principale per GCP. kubectl fornisce l'interfaccia a riga di comando per l'esecuzione dei comandi nei cluster GKE.

Se preferisci utilizzare la tua shell locale, devi installare l'interfaccia a riga di comando gcloud.

Per aprire Cloud Shell o configurare la tua shell locale, completa i seguenti passaggi:

Cloud Shell

Per avviare Cloud Shell, completa i seguenti passaggi:

  1. Vai a Google Cloud Console.

    Google Cloud console

  2. Nell'angolo in alto a destra della console, fai clic sul pulsante Attiva Google Cloud Shell:

Una sessione di Cloud Shell si apre all'interno di un frame nella parte inferiore della console. Utilizzi questa shell per eseguire i comandi gcloud e kubectl.

Guscio locale

Per installare l'interfaccia a riga di comando gcloud e lo strumento kubectl, completa questi passaggi:

  1. Installa e inizializza l'interfaccia a riga di comando di Google Cloud.
  2. Se stai testando l'adattatore solo in locale, non devi completare altri passaggi e potrai continuare a creare un set di dati. Se stai eseguendo il deployment dell'adattatore in GKE, installa lo strumento a riga di comando kubectl eseguendo questo comando:

    gcloud components install kubectl

Creazione di un set di dati

Se non hai già creato un set di dati dell'API Cloud Healthcare, crea un set di dati completando i seguenti passaggi:

console

  1. Nella console, vai alla pagina Set di dati.

    Vai alla pagina Set di dati

  2. Fai clic su Crea set di dati.
  3. Nel campo Nome, inserisci un identificatore del set di dati. L'ID del set di dati deve avere quanto segue:
    • Un ID univoco nella sua posizione
    • Una stringa Unicode di 1-256 caratteri composta da quanto segue:
      • Numeri
      • Lettere
      • Trattini bassi
      • Trattini
      • Cicli
  4. Nella sezione Tipo di località, scegli uno dei seguenti tipi di località:
    • Area geografica: il set di dati si trova all'interno di un'area geografica di Google Cloud. Dopo aver selezionato, digita o seleziona la località nel campo Area geografica.
    • Più aree geografiche: il set di dati si trova all'interno di una località che copre più aree geografiche Google Cloud. Dopo aver selezionato, digita o seleziona la località a più aree geografiche nel campo Più aree geografiche.

Il nuovo set di dati viene visualizzato nell'elenco dei set di dati.

gcloud

Per creare un set di dati, esegui il comando gcloud healthcare datasets create:

gcloud healthcare datasets create DATASET_ID \
    --location=LOCATION

Se la richiesta riesce, il comando restituisce il seguente output:

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

Creazione di un argomento Pub/Sub e una sottoscrizione

Per ricevere notifiche quando vengono creati o importati messaggi, devi configurare un argomento Pub/Sub con il tuo archivio HL7v2. Per ulteriori informazioni, consulta Configurazione delle notifiche Pub/Sub.

Per creare un argomento, procedi nel seguente modo:

console

  1. Vai alla pagina Argomenti di Pub/Sub nella console.

    Vai alla pagina Argomenti Pub/Sub

  2. Fai clic su Crea argomento.

  3. Inserisci un nome per l'argomento con il seguente URI:

    projects/PROJECT_ID/topics/TOPIC_NAME

    dove PROJECT_ID è il tuo ID progetto Google Cloud.

  4. Fai clic su Crea.

gcloud

Per creare un argomento, esegui il comando gcloud pubsub topics create:

gcloud pubsub topics create projects/PROJECT_ID/topics/TOPIC_NAME

Se la richiesta riesce, il comando restituisce il seguente output:

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

Per creare un abbonamento:

console

  1. Vai alla pagina Argomenti di Pub/Sub nella console.

    Vai alla pagina Argomenti Pub/Sub

  2. Fai clic su un argomento del progetto.

  3. Fai clic su Crea sottoscrizione.

  4. Inserisci un nome per la sottoscrizione:

    projects/PROJECT_ID/subscriptions/SUBSCRIPTION_NAME

  5. Lascia Tipo di pubblicazione impostato su Pull e fai clic su Crea.

gcloud

Per creare un abbonamento, esegui il comando gcloud pubsub subscriptions create:

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

Se la richiesta riesce, il comando restituisce il seguente output:

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

Creazione di un archivio HL7v2 configurato con un argomento Pub/Sub

Creare un archivio HL7v2 e configurarlo con un argomento Pub/Sub. Per creare un archivio HL7v2, devi avere già creato un set di dati. Ai fini di questo tutorial, utilizza lo stesso progetto per il tuo archivio HL7v2 e per l'argomento Pub/Sub.

Per creare un archivio HL7v2 configurato con un argomento Pub/Sub, completa i seguenti passaggi:

Curling

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"

Se la richiesta ha esito positivo, il server restituisce la risposta in formato 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

Se la richiesta ha esito positivo, il server restituisce la risposta in formato JSON:

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

Configurazione delle autorizzazioni Pub/Sub

Per inviare notifiche a Pub/Sub quando viene creato o importato un messaggio HL7v2, devi configurare le autorizzazioni Pub/Sub sull'API Cloud Healthcare. Questa operazione deve essere eseguita una volta per progetto.

Per aggiungere il ruolo di pubsub.publisher obbligatorio all'account di servizio del progetto, procedi nel seguente modo:

console

  1. Nella pagina IAM della console, verifica che il ruolo Agente di servizio sanitario sia visualizzato nella colonna Ruolo per l'account di servizio del progetto pertinente. Il nome dell'account è service-PROJECT_NUMBER@gcp-sa-health.iam.gserviceaccount.com. Per informazioni sull'individuazione di PROJECT_NUMBER, consulta Identificazione dei progetti.

  2. Fai clic sull'icona a forma di matita nella colonna Eredità corrispondente al ruolo. Viene visualizzato il riquadro Modifica autorizzazioni.

  3. Fai clic su Aggiungi un altro ruolo e cerca il ruolo Publisher Pub/Sub.

  4. Seleziona il ruolo e fai clic su Salva. Il ruolo pubsub.publisher viene aggiunto all'account di servizio.

gcloud

Per aggiungere le autorizzazioni dell'account di servizio, esegui il comando gcloud projects add-iam-policy-binding. Per informazioni su come trovare PROJECT_ID e PROJECT_NUMBER, consulta la pagina Identificare i progetti.

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

Pull dell'immagine Docker preconfigurata

L'adattatore MLLP è un'applicazione containerizzata, allestita in un'immagine Docker preconfigurata in Container Registry.

Per estrarre la versione più recente dell'immagine, esegui questo comando:

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

Test dell'adattatore MLLP in locale

Quando testi l'adattatore localmente, puoi configurarlo in modo che venga eseguito come destinatario, publisher o entrambi. Le configurazioni del ricevitore e del publisher hanno le seguenti differenze chiave:

  • Quando l'adattatore viene eseguito come destinatario, riceve messaggi HL7v2 da un'origine esterna e chiama messages.ingest per importare i messaggi in un archivio HL7v2, creando così una notifica Pub/Sub. La notifica viene inviata alle applicazioni iscritte all'argomento Pub/Sub dell'archivio HL7v2.
  • Quando l'adattatore viene eseguito come publisher, ascolta i messaggi HL7v2 creati o importati in un archivio HL7v2 utilizzando messages.create o messages.ingest. Dopo aver creato un messaggio, viene inviata una notifica Pub/Sub all'adattatore e quest'ultimo pubblica i messaggi per un destinatario esterno.

Le seguenti sezioni descrivono come eseguire l'adattatore in modo che agisca come destinatario o publisher.

Dopo aver verificato di poter eseguire l'adattatore MLLP sulla tua macchina locale, puoi passare alla sezione successiva sul deployment dell'adattatore MLLP in Google Kubernetes Engine.

Test dell'adattatore MLLP localmente come ricevitore

Quando l'adattatore riceve un messaggio HL7v2 da un'origine esterna, ad esempio un centro di assistenza sanitaria, l'adattatore chiama messages.ingest e importa il messaggio HL7v2 nell'archivio HL7v2 configurato. Puoi verificare il problema nel codice sorgente dell'adattatore.

Per testare l'adattatore in locale come ricevitore, svolgi i seguenti passaggi:

  1. Sul computer in cui hai eseguito il pull dell'immagine Docker predefinita, esegui il comando seguente:

    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
    

    dove:

    • PROJECT_ID è l'ID del progetto Google Cloud contenente l'archivio HL7v2.
    • LOCATION è l'area geografica in cui si trova il tuo negozio HL7v2.
    • DATASET_ID è l'ID del set di dati principale dell'archivio HL7v2.
    • HL7V2_STORE_ID è l'ID per l'archivio HL7v2 a cui invii i messaggi HL7v2.

    Dopo aver eseguito il comando precedente, l'adattatore stampa un messaggio simile al seguente e inizia a essere eseguito sulla macchina locale all'indirizzo IP 127.0.0.1 sulla porta 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.
    

    Se si verifica un errore, segui questi passaggi per la risoluzione dei problemi:

  2. Per continuare a eseguire i test mentre l'adattatore viene eseguito come processo in primo piano, apri un terminale diverso sulla macchina locale.

  3. Nel nuovo terminale, per installare Netcat, esegui il comando seguente:

    sudo apt install netcat
    
  4. Scarica il file hl7v2-mllp-sample.txt e salvalo sulla tua macchina locale.

  5. Per inviare il messaggio HL7v2 all'adattatore, nella directory in cui hai scaricato il file, esegui questo comando. L'adattatore MLLP è in ascolto sull'host locale sulla porta 2575. Il comando invia il messaggio tramite l'adattatore MLLP nell'archivio HL7v2.

    Linux

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

    Se il messaggio è stato importato correttamente nell'archivio HL7v2, il comando restituisce il seguente output:

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

    Questo output indica che l'archivio HL7v2 ha risposto con un tipo di risposta AA (Application Accept), pertanto il messaggio è stato convalidato e importato correttamente.

  6. Per verificare che il messaggio sia stato inviato, apri il terminale in cui hai eseguito l'adattatore. L'output dovrebbe essere simile all'esempio riportato di seguito:

     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. Il messaggio viene archiviato nel tuo archivio HL7v2, quindi puoi chiamare messages.list per visualizzarlo:

    Curling

    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"
    

    Se la richiesta ha esito positivo, il server restituisce l'ID del messaggio in un percorso risorsa:

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

    Se la richiesta ha esito positivo, il server restituisce l'ID del messaggio in un percorso risorsa:

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

Test dell'adattatore MLLP localmente come publisher

Quando testi l'adattatore come publisher, puoi creare i messaggi chiamando messages.create o messages.ingest e fornendo un file messaggio come dati binari.

L'adattatore riconosce automaticamente i messaggi Pub/Sub inviati tramite messages.create e messages.ingest.

L'adattatore ti avvisa quando recupera e invia i messaggi Pub/Sub. L'adattatore è un sottoscrittore Pub/Sub, quindi accetta automaticamente questi messaggi. Di conseguenza, vengono rimossi dalla coda dei messaggi nell'abbonamento Pub/Sub configurato con l'adattatore.

Per estrarre dalla sottoscrizione Pub/Sub e verificare separatamente che i messaggi siano stati pubblicati, devi creare una seconda sottoscrizione Pub/Sub assegnata all'argomento che hai creato in precedenza. I messaggi inviati alla seconda sottoscrizione non vengono riconosciuti automaticamente dall'adattatore e continuano a essere rimossi.

Per creare una seconda sottoscrizione Pub/Sub assegnata all'argomento creato in precedenza, procedi nel seguente modo:

console

  1. Vai alla pagina Argomenti di Pub/Sub nella console.

    Vai alla pagina Argomenti Pub/Sub

  2. Fai clic su un argomento del progetto. Questo è l'argomento che hai utilizzato per creare la sottoscrizione iniziale.

  3. Fai clic su Crea sottoscrizione.

  4. Inserisci un nome per la sottoscrizione:

    projects/PROJECT_ID/subscriptions/SECOND_SUBSCRIPTION_NAME

    Lascia Tipo di consegna impostato su Pull.

  5. Fai clic su Crea.

gcloud

Per creare una seconda sottoscrizione Pub/Sub assegnata all'argomento creato in precedenza, esegui il comando gcloud pubsub subscriptions create:

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

Se la richiesta riesce, il comando restituisce il seguente output:

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

Per testare l'adattatore localmente come editore, completa i seguenti passaggi sulla macchina in cui hai eseguito il pull dell'immagine Docker preconfigurata:

  1. Installa Netcat:

    sudo apt install netcat
    
  2. Scarica il file hl7v2-mllp-ack-sample.txt e salvalo sulla tua macchina locale. Il file contiene un messaggio ACK richiesto dall'adattatore come risposta quando tenta di pubblicare un messaggio.

  3. Per consentire a Netcat di rimanere in ascolto delle connessioni in entrata sulla porta 2525, nella directory in cui hai scaricato il file, esegui il comando seguente.

    Linux

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

    Dopo aver avviato Netcat, viene visualizzato un messaggio di output simile al seguente esempio:

    listening on [any] 2525 ...
    
  4. Netcat viene eseguito come processo in primo piano, quindi per continuare con i test, apri un terminale diverso sulla macchina locale.

  5. Per avviare l'adattatore, nel nuovo terminale esegui il comando seguente:

    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
    

    dove:

    • PROJECT_ID è l'ID del progetto Google Cloud contenente l'archivio HL7v2.
    • LOCATION è l'area geografica in cui si trova il tuo negozio HL7v2.
    • DATASET_ID è l'ID del set di dati principale dell'archivio HL7v2.
    • HL7V2_STORE_ID è l'ID per l'archivio HL7v2 a cui invii i messaggi HL7v2.
    • PROJECT_ID è l'ID per il progetto Google Cloud contenente l'argomento Pub/Sub.
    • PUBSUB_SUBSCRIPTION è il nome del primo abbonamento che hai creato e che è stato associato al tuo argomento Pub/Sub. L'adattatore utilizza i messaggi di questa sottoscrizione e li riconosce automaticamente, quindi per visualizzare i messaggi pubblicati sull'argomento devi estrarre i messaggi dalla seconda sottoscrizione creata in precedenza.

    Dopo aver eseguito il comando precedente, l'adattatore inizia a essere eseguito sulla tua macchina locale all'indirizzo IP 127.0.0.1 sulla porta 2575.

    Se si verifica un errore, segui questi passaggi per la risoluzione dei problemi:

    L'adattatore viene eseguito come processo in primo piano, quindi per continuare con i test, apri un terminale diverso sul computer locale.

  6. Scarica il file hl7v2-sample.json e salvalo sulla tua macchina locale. Nella directory in cui hai scaricato il file, chiama il metodo messages.create per creare il messaggio in un archivio HL7v2.

    Curling

    Per creare un messaggio HL7v2, effettua una richiesta POST e specifica le seguenti informazioni:

    • Il nome del set di dati padre
    • Il nome dell'archivio HL7v2.
    • Un messaggio
    • Un token di accesso

    L'esempio seguente mostra una richiesta POST che utilizza curl e un file JSON di esempio chiamato 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"
    

    Se la richiesta ha esito positivo, il server restituisce la risposta in formato 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

    Per creare un messaggio HL7v2, effettua una richiesta POST e specifica le seguenti informazioni:

    • Il nome del set di dati padre
    • Il nome dell'archivio HL7v2.
    • Un messaggio
    • Un token di accesso

    L'esempio seguente mostra una richiesta POST tramite Windows PowerShell e un file JSON di esempio denominato 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
    

    Se la richiesta ha esito positivo, il server restituisce la risposta in formato 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"
        }
      ]
    }
    

    Dopo aver creato il messaggio, l'adattatore MLLP restituisce la seguente risposta:

    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. Nel terminale in cui hai eseguito Netcat, viene visualizzato un output simile ai seguenti. L'output indica che il messaggio è stato pubblicato:

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

    Corrisponde al valore del campo data della risposta ricevuta durante la creazione del messaggio. È uguale al valore di data nel file hl7v2-sample.json.

  8. Per visualizzare il messaggio che l'adattatore ha pubblicato nell'argomento Pub/Sub, esegui il comando gcloud pubsub subscriptions pull sulla seconda sottoscrizione Pub/Sub che hai creato:

    gcloud pubsub subscriptions pull --auto-ack SECOND_SUBSCRIPTION
    

    Il comando restituisce il seguente output sul messaggio HL7v2 creato. Osserva il valore publish=true nella colonna ATTRIBUTES, che indica che il messaggio è stato pubblicato in 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  |
    └-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘
    

Pubblicazione di messaggi con destinatari esterni diversi

Puoi configurare l'archivio HL7v2 con più argomenti Pub/Sub e utilizzare i filtri per inviare notifiche a diversi argomenti Pub/Sub. Puoi quindi eseguire un adattatore MLLP per ogni argomento Pub/Sub per pubblicare i messaggi su un destinatario esterno diverso.

Per configurare l'archivio HL7v2 con più argomenti Pub/Sub e un filtro per ogni argomento, completa i seguenti passaggi:

  1. Crea due argomenti Pub/Sub e una sottoscrizione per ogni argomento. Per ulteriori informazioni, consulta la sezione Creazione di un argomento e una sottoscrizione Pub/Sub.

  2. Esegui questo comando:

    Curling

    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"
    

    Se la richiesta ha esito positivo, il server restituisce la risposta in formato 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
    

    Se la richiesta ha esito positivo, il server restituisce la risposta in formato 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\""
        }
      ]
    }
    

Test del routing dei messaggi

Per verificare il routing dei messaggi, completa i passaggi riportati nelle sezioni seguenti.

Configurazione e avvio del primo ricevitore e dell'adattatore

Per configurare e avviare il primo ricevitore e l'alimentatore, procedi nel seguente modo:

  1. Sul computer in cui hai eseguito il pull dell'immagine Docker predefinita, esegui il comando seguente per installare Netcat:

    sudo apt install netcat
    
  2. Scarica hl7v2-mllp-ack-sample.txt, se non l'hai ancora fatto. Il file contiene un messaggio ACK utilizzato come risposta dall'adattatore quando tenta di pubblicare un messaggio.

  3. Per impostare la porta 2525 per il primo ricevitore, esegui il seguente comando:

    Linux

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

    All'avvio del processo Netcat, viene visualizzato il seguente output:

    listening on [any] 2525 ...
    
  4. Per avviare il primo adattatore, esegui il seguente comando in un nuovo terminale:

    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
    

    dove:

    • PROJECT_ID è l'ID del progetto Google Cloud contenente l'archivio HL7v2.
    • LOCATION è l'area geografica in cui si trova il tuo negozio HL7v2.
    • DATASET_ID è l'ID del set di dati principale dell'archivio HL7v2.
    • HL7V2_STORE_ID è l'ID per l'archivio HL7v2 a cui invii i messaggi HL7v2.
    • PROJECT_ID è l'ID per il progetto Google Cloud contenente l'argomento Pub/Sub.
    • PUBSUB_SUBSCRIPTION è il nome del primo abbonamento che hai creato e che è associato al tuo primo argomento Pub/Sub. L'adattatore consuma i messaggi da questa sottoscrizione e li riconosce automaticamente.

    Dopo aver eseguito questo comando, l'adattatore inizia a essere eseguito sulla macchina locale il giorno 127.0.0.1:2575. Pubblica i nuovi messaggi sul primo destinatario esterno sulla porta 2525.

Configurazione e avvio del secondo ricevitore e dell'adattatore

Per configurare e avviare il secondo ricevitore e l'alimentatore, procedi nel seguente modo:

  1. Sul computer in cui hai eseguito il pull dell'immagine Docker predefinita, esegui il comando seguente per installare Netcat:

    sudo apt install netcat
    
  2. Scarica hl7v2-mllp-ack-sample.txt, se non l'hai ancora fatto. Il file contiene un messaggio ACK utilizzato come risposta dall'adattatore quando tenta di pubblicare un messaggio.

  3. Per impostare la porta 2526 per il secondo ricevitore, esegui il comando seguente.

    Linux

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

    All'avvio del processo Netcat, viene visualizzato il seguente output:

    listening on [any] 2526 ...
    
  4. Per avviare il secondo adattatore, esegui il seguente comando in un nuovo terminale:

    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
    

    dove:

    • PROJECT_ID è l'ID del progetto Google Cloud contenente l'archivio HL7v2.
    • LOCATION è l'area geografica in cui si trova il tuo negozio HL7v2.
    • DATASET_ID è l'ID del set di dati principale dell'archivio HL7v2.
    • HL7V2_STORE_ID è l'ID per l'archivio HL7v2 a cui invii i messaggi HL7v2.
    • PROJECT_ID è l'ID per il progetto Google Cloud contenente l'argomento Pub/Sub.
    • SECOND_PUBSUB_SUBSCRIPTION è il nome del secondo abbonamento che hai creato e che è associato al tuo secondo argomento Pub/Sub. L'adattatore consuma i messaggi da questa sottoscrizione e li riconosce automaticamente.

    Dopo aver eseguito questo comando, l'adattatore inizia a essere eseguito sulla macchina locale sulla porta IP 127.0.0.1:2576. Pubblica i nuovi messaggi sul secondo destinatario esterno sulla porta 2526.

Pubblicazione di un messaggio sul primo destinatario

Per creare un messaggio che verrà pubblicato solo sul primo destinatario esterno, completa questi passaggi:

  1. Scarica hl7v2-sample1.json.

  2. Nella directory in cui hai scaricato hl7v2-sample1.json, chiama il metodo messages.create per creare il messaggio in un archivio HL7v2.

    Curling

    Per creare un messaggio HL7v2, effettua una richiesta POST e specifica le seguenti informazioni:

    • Il nome del set di dati padre
    • Il nome dell'archivio HL7v2.
    • Un messaggio
    • Un token di accesso

    L'esempio seguente mostra una richiesta POST che utilizza curl e un file JSON di esempio, 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"
    

    Se la richiesta ha esito positivo, il server restituisce la risposta in formato 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

    Per creare un messaggio HL7v2, effettua una richiesta POST e specifica le seguenti informazioni:

    • Il nome del set di dati padre
    • Il nome dell'archivio HL7v2.
    • Un messaggio
    • Un token di accesso

    L'esempio seguente mostra una richiesta POST tramite Windows PowerShell e un file JSON di esempio denominato 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
    

    Se la richiesta ha esito positivo, il server restituisce la risposta in formato 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"
       }
     ]
    }
    

    In questa risposta, sendFacility è impostato su SEND_FACILITY_1, pertanto la notifica Pub/Sub viene inviata solo al primo argomento Pub/Sub. Dopo aver creato il messaggio, il primo adattatore MLLP restituisce la seguente risposta:

    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.
    

    Il secondo adattatore MLLP non restituisce alcuna risposta perché non viene inviata alcuna notifica al secondo argomento Pub/Sub.

    Nel terminale in cui hai eseguito il primo processo Netcat, viene visualizzato il seguente output. Questo output indica che il messaggio è stato pubblicato.

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

    Questo output corrisponde al valore del campo data della risposta che hai ricevuto quando hai creato il messaggio. È uguale al valore di data nel file hl7v2-sample1.json.

Pubblicazione di un messaggio sul secondo destinatario

Per creare un messaggio che verrà pubblicato solo sul secondo destinatario esterno, segui questi passaggi:

  1. Apri un nuovo terminale sul computer locale.

  2. Per creare un messaggio che verrà pubblicato solo sul secondo destinatario esterno, scarica hl7v2-sample2.json.

  3. Nella directory in cui hai scaricato hl7v2-sample2.json, chiama il metodo messages.create per creare il messaggio in un archivio HL7v2.

    Curling

    Per creare un messaggio HL7v2, effettua una richiesta POST e specifica le seguenti informazioni:

    • Il nome del set di dati padre
    • Il nome dell'archivio HL7v2.
    • Un messaggio
    • Un token di accesso

    L'esempio seguente mostra una richiesta POST che utilizza curl e un file JSON di esempio, 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"
    

    Se la richiesta ha esito positivo, il server restituisce la risposta in formato 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

    Per creare un messaggio HL7v2, effettua una richiesta POST e specifica le seguenti informazioni:

    • Il nome del set di dati padre
    • Il nome dell'archivio HL7v2.
    • Un messaggio
    • Un token di accesso

    L'esempio seguente mostra una richiesta POST utilizzando Windows PowerShell e un file JSON di esempio, 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
    

    Se la richiesta ha esito positivo, il server restituisce la risposta in formato 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"
       }
     ]
    }
    

    Tieni presente che la funzione sendFacility è SEND_FACILITY_2, pertanto la notifica Pub/Sub viene inviata solo al secondo argomento Pub/Sub. Dopo aver creato il messaggio, il primo adattatore MLLP non restituisce alcuna risposta, mentre il secondo adattatore MLLP restituisce la seguente risposta:

    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.
    

    Nel terminale in cui hai eseguito il secondo processo Netcat, viene visualizzato il seguente output. Questo output indica che il messaggio è stato pubblicato.

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

    Questo output corrisponde al valore del campo data della risposta che hai ricevuto quando hai creato il messaggio. È uguale al valore di data nel file hl7v2-sample2.json.

Deployment dell'adattatore MLLP in Google Kubernetes Engine

Quando si trasmettono messaggi HL7v2 su MLLP dal centro di cura, una possibile configurazione è inviare i messaggi a un adattatore implementato in Google Cloud e inoltrarli all'API Cloud Healthcare.

L'adattatore MLLP viene eseguito come applicazione stateless su un cluster GKE. Un cluster GKE è un gruppo gestito di istanze VM per l'esecuzione di applicazioni containerizzate. Le applicazioni stateless sono applicazioni che non archiviano dati o stato delle applicazioni nel cluster o nell'archiviazione permanente. I dati e lo stato delle applicazioni rimangono invece con il client, il che rende le applicazioni stateless più scalabili.

GKE utilizza il controller Deployment per eseguire il deployment di applicazioni stateless come pod uniformi e non univoci. I deployment gestiscono lo stato desiderato dell'applicazione: quanti pod dovrebbero eseguire l'applicazione, quale versione dell'immagine container deve essere eseguita, quali pod devono essere etichettati e così via. Lo stato desiderato può essere modificato in modo dinamico tramite gli aggiornamenti alla specifica dei pod di deployment.

Mentre esegui il deployment dell'adattatore, crei un controller di servizio che ti consente di connettere l'adattatore all'API Cloud Healthcare utilizzando il bilanciamento del carico interno.

Se non hai mai utilizzato GKE, devi completare la guida rapida di GKE per scoprire come funziona il prodotto.

Aggiunta delle autorizzazioni API Pub/Sub all'account di servizio GKE

Come indicato nella documentazione di GKE sull'autenticazione in Cloud Platform con account di servizio, ogni nodo in un cluster di container è un'istanza di Compute Engine. Pertanto, quando l'adattatore MLLP viene eseguito su un cluster di container, eredita automaticamente gli ambiti delle istanze di Compute Engine in cui viene eseguito il deployment.

Google Cloud crea automaticamente un account di servizio denominato "Account di servizio predefinito di Compute Engine" e GKE associa questo account di servizio ai nodi creati da GKE. A seconda della configurazione del progetto, l'account di servizio predefinito potrebbe disporre o meno delle autorizzazioni per utilizzare altre API Cloud Platform. GKE assegna anche alcuni ambiti di accesso limitati alle istanze di Compute Engine,

Per ottenere risultati ottimali, non eseguire l'autenticazione per altri servizi Google Cloud (ad esempio Pub/Sub) dai pod in esecuzione su GKE aggiornando le autorizzazioni dell'account di servizio predefinito o assegnando più ambiti di accesso alle istanze di Compute Engine. Crea invece i tuoi account di servizio personalizzati.

Devi concedere le autorizzazioni Pub/Sub necessarie al cluster di container, ma puoi anche concedere le autorizzazioni per scrivere metriche in Cloud Monitoring.

Per creare un nuovo account di servizio che contenga solo gli ambiti richiesti dal container container, segui questi passaggi:

console

Crea un account di servizio:

  1. Nella console, vai alla pagina Crea account di servizio.

    Vai a Crea account di servizio

  2. Seleziona un progetto.

  3. Inserisci un nome nel campo Nome account di servizio. La console compila il campo ID account di servizio in base a questo nome.

    (Facoltativo) Nel campo Descrizione account di servizio, inserisci una descrizione.

  4. Fai clic su Crea.

  5. Fai clic sul campo Seleziona un ruolo.

    In Tutti i ruoli, fai clic su Pub/Sub > Iscritti Pub/Sub.

  6. Fai clic su Aggiungi un altro ruolo, quindi sul campo Seleziona un ruolo.

    In Tutti i ruoli, fai clic su Cloud Healthcare > Importazione di messaggi HL7v2 per il settore sanitario.

  7. (Facoltativo) Se vuoi abilitare il monitoraggio, fai clic su Aggiungi un altro ruolo, quindi sul campo Seleziona un ruolo.

    In Tutti i ruoli, fai clic su Monitoraggio > Monitoraggio dello strumento di misurazione delle metriche.

  8. Fai clic su Continua.

  9. Fai clic su Fine per completare la creazione dell'account di servizio.

    Non chiudere la finestra del browser. Utilizzerai la finestra nella procedura successiva.

Crea una chiave dell'account di servizio:

  1. Nella console, fai clic sull'indirizzo email dell'account di servizio che hai creato.

  2. Fai clic su Chiavi.

  3. Fai clic su Aggiungi chiave, quindi su Crea nuova chiave.

  4. Fai clic su Crea. Il file di una chiave JSON viene scaricato sul computer.

  5. Fai clic su Chiudi.

gcloud

  1. Per creare l'account di servizio, esegui il comando gcloud iam service-accounts create.

    gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
    

    L'output è l'account di servizio:

    Created service account SERVICE_ACCOUNT_NAME.
    
  2. Per concedere ogni ruolo all'account di servizio, esegui il comando gcloud projects add-iam-policy-binding.

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

    L'output include il criterio aggiornato:

    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. Per creare una chiave dell'account di servizio, esegui il comando gcloud iam service-accounts keys create.

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

    Dopo la creazione dell'account di servizio, sul computer viene scaricato un file di chiave JSON contenente le credenziali dell'account di servizio. Utilizzerai questo file della chiave per configurare l'adattatore MLLP per l'autenticazione nell'API Cloud Healthcare, nell'API Pub/Sub e nell'API Cloud Monitoring utilizzando il flag --service-account durante la creazione del cluster.

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

Crea il cluster

Per creare il cluster in GKE, esegui il comando gcloud container clusters create:

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

dove:

  • COMPUTE_ZONE è la zona in cui viene eseguito il deployment del cluster. Una zona è una località geografica approssimativa in cui risiedono i cluster e le relative risorse. Ad esempio, us-west1-a è una zona nell'area geografica us-west. Se hai impostato una zona predefinita con gcloud config set compute/zone, il valore di questo flag sostituisce la località predefinita.
  • CLIENT_EMAIL è l'identificatore dell'account di servizio. Puoi trovare questo indirizzo email nel file della chiave dell'account di servizio nel campo "client_email":. Ha il formato SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.

Il comando restituisce un output simile al seguente:

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

Dopo aver creato il cluster, GKE crea tre istanze VM di Compute Engine. Per verificarlo, elenca le istanze con il comando seguente:

gcloud compute instances list

Configurazione del deployment

Quando esegui il deployment di un'applicazione in GKE, definisci le proprietà del deployment tramite un file manifest di deployment, che in genere è un file YAML. Per un esempio, consulta la pagina relativa alla creazione di un deployment.

  1. Apri un terminale separato.

  2. Utilizzando un editor di testo, crea un file manifest di deployment denominato mllp_adapter.yaml con il seguente contenuto:

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

dove:

  • PROJECT_ID è l'ID del progetto Google Cloud contenente l'archivio HL7v2.
  • LOCATION è l'area geografica in cui si trova il tuo negozio HL7v2.
  • DATASET_ID è l'ID del set di dati principale dell'archivio HL7v2.
  • HL7V2_STORE_ID è l'ID per l'archivio HL7v2 a cui invii i messaggi HL7v2.

Il deployment ha le seguenti proprietà:

  • spec: replicas: è il numero di pod replicati gestiti dal deployment.
  • spec: template: metadata: labels: è l'etichetta assegnata a ciascun pod, che viene utilizzata dal deployment per gestire i pod.
  • spec: template: spec: è la specifica dei pod, che definisce come deve essere eseguito ogni pod.
  • spec: containers include il nome del container da eseguire in ogni pod e l'immagine del container che deve essere eseguita.

Per ulteriori informazioni sulla specifica del deployment, consulta la documentazione di riferimento sull'API Deployment.

Configurazione del servizio

Per rendere l'adattatore MLLP accessibile alle applicazioni all'esterno del cluster (ad esempio, un centro di assistenza sanitaria), devi configurare un bilanciatore del carico interno.

Se non hai configurato una VPN, le applicazioni possono accedere all'adattatore MLLP tramite il bilanciatore del carico interno purché le applicazioni utilizzino la stessa rete VPC e si trovino nella stessa area geografica Google Cloud. Ad esempio, per rendere l'adattatore accessibile a un'istanza VM di Compute Engine nella stessa area geografica e sulla stessa rete VPC, puoi aggiungere un bilanciatore del carico interno alla risorsa Servizio del cluster.

Nella directory in cui hai creato il file manifest di deployment, utilizza l'editor di testo per creare un file manifest del servizio denominato mllp_adapter_service.yaml con i contenuti seguenti. Questo file è responsabile della configurazione del bilanciamento del carico interno:

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

Il servizio ha le seguenti proprietà:

  • metadata: name: è il nome che l'utente sceglie per il Servizio. In questo caso, è mllp-adapter-service.
  • metadata: annotations: è un'annotazione che specifica che deve essere configurato un bilanciatore del carico interno.
  • spec: type: è il tipo di bilanciatore del carico.
  • ports: port: consente di specificare la porta sulla quale il servizio può ricevere il traffico da altri servizi nello stesso cluster. Viene utilizzata la porta MLLP predefinita di 2575.
  • ports: targetPort: viene utilizzato per specificare la porta su ciascun pod in cui è in esecuzione il servizio.
  • spec: selector: app: specifica i pod scelti come target dal servizio.

Anche se è possibile specificare un indirizzo IP per il bilanciatore del carico (utilizzando il campo clusterIP), il bilanciatore del carico può generare un proprio indirizzo IP a cui inviare i messaggi. Per ora, consenti al cluster di generare l'indirizzo IP che utilizzerai più avanti in questo tutorial.

Per ulteriori informazioni sul bilanciamento del carico interno, consulta la documentazione di GKE.

Per ulteriori informazioni sulla specifica del servizio, consulta il riferimento dell'API Service.

Deployment del deployment

Per eseguire il deployment dell'adattatore in un cluster GKE, nella directory contenente il file manifest di deployment mllp_adapter.yaml, esegui il comando seguente:

kubectl apply -f mllp_adapter.yaml

Il comando restituisce il seguente output:

deployment.extensions "mllp-adapter-deployment" created

Ispezione del deployment

Dopo aver creato il deployment, puoi utilizzare lo strumento kubectl per ispezionarlo.

Per ottenere informazioni dettagliate sul deployment, esegui questo comando:

kubectl describe deployment mllp-adapter

Per elencare il pod creato dal deployment, esegui questo comando:

kubectl get pods -l app=mllp-adapter

Per ottenere informazioni sul pod creato:

kubectl describe pod POD_NAME

Se il deployment è riuscito, l'ultima parte dell'output del comando precedente dovrebbe contenere le seguenti informazioni:

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

Deployment del servizio e creazione del bilanciatore del carico interno

Per creare il bilanciatore del carico interno, esegui questo comando nella directory contenente il file manifest del servizio mllp_adapter_service.yaml:

kubectl apply -f mllp_adapter_service.yaml

Il comando restituisce il seguente output:

service "mllp-adapter-service" created

Ispezione del servizio

Dopo aver creato il servizio, ispezionalo per verificare che sia stato configurato.

Per controllare il bilanciatore del carico interno, esegui il comando seguente:

kubectl describe service mllp-adapter-service

L'output del comando è simile al seguente esempio:

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

La compilazione dell'indirizzo IP LoadBalancer Ingress potrebbe richiedere fino a un minuto. Utilizzerai questo indirizzo IP e la porta 2575 per accedere al servizio dall'esterno del cluster nel passaggio successivo.

Creazione di una VM di Compute Engine e invio di messaggi

Mentre in precedenza in questo tutorial hai testato l'adattatore MLLP localmente e hai inviato messaggi HL7v2 all'archivio HL7v2, ora invierai i messaggi da una VM di Compute Engine all'adattatore MLLP in esecuzione su GKE. I messaggi vengono quindi inoltrati a un archivio HL7v2.

Per inviare richieste dalla nuova istanza al cluster GKE, l'istanza e quelle esistenti devono trovarsi nella stessa area geografica e utilizzare la stessa rete VPC.

Alla fine di questa sezione, verranno elencate le notifiche pubblicate nell'argomento Pub/Sub e i messaggi HL7v2 nell'archivio HL7v2. Per eseguire queste attività, è necessario concedere all'istanza VM di Compute Engine le autorizzazioni necessarie. Prima di creare l'istanza, crea un nuovo account di servizio con le autorizzazioni necessarie completando i passaggi seguenti:

console

Crea un account di servizio:

  1. Nella console, vai alla pagina Crea account di servizio.

    Vai a Crea account di servizio

  2. Seleziona un progetto.

  3. Inserisci un nome nel campo Nome account di servizio. La console compila il campo ID account di servizio in base a questo nome.

    (Facoltativo) Nel campo Descrizione account di servizio, inserisci una descrizione.

  4. Fai clic su Crea.

  5. Fai clic sul campo Seleziona un ruolo.

    In Tutti i ruoli, fai clic su Pub/Sub > Iscritti Pub/Sub.

  6. Fai clic su Aggiungi un altro ruolo, quindi sul campo Seleziona un ruolo.

    In Tutti i ruoli, fai clic su Cloud Healthcare > Healthcare HL7v2 Message Consumer.

  7. Fai clic su Continua.

  8. Fai clic su Fine per completare la creazione dell'account di servizio.

    Non chiudere la finestra del browser. Utilizzerai la finestra nella procedura successiva.

Crea una chiave dell'account di servizio:

  1. Nella console, fai clic sull'indirizzo email dell'account di servizio che hai creato.

  2. Fai clic su Chiavi.

  3. Fai clic su Aggiungi chiave, quindi su Crea nuova chiave.

  4. Fai clic su Crea. Il file di una chiave JSON viene scaricato sul computer.

  5. Fai clic su Chiudi.

gcloud

  1. Per creare l'account di servizio, esegui il comando gcloud iam service-accounts create.

    gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
    

    L'output è l'account di servizio:

    Created service account SERVICE_ACCOUNT_NAME.
    
  2. Per concedere ogni ruolo all'account di servizio, esegui il comando 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
    

    L'output include il criterio aggiornato:

    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. Per creare una chiave dell'account di servizio, esegui il comando gcloud iam service-accounts keys create.

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

    Dopo la creazione dell'account di servizio, sul computer viene scaricato un file di chiave JSON contenente le credenziali dell'account di servizio.

I passaggi seguenti mostrano come creare un'istanza di macchina virtuale Linux in Compute Engine:

console

  1. Nella console, vai alla pagina Istanze VM.

    Vai alla pagina Istanze VM

  2. Fai clic su Crea istanza.

  3. Scegli un'area geografica e una zona per l'istanza che corrisponde alla zona selezionata al momento della creazione del cluster. Ad esempio, se hai utilizzato us-central1-a per COMPUTE_ZONE quando hai creato il cluster, nella schermata di creazione dell'istanza, seleziona us-central1 (Iowa) per l'area geografica e us-central1-a per la zona.

  4. Nella sezione Disco di avvio, fai clic su Cambia per iniziare a configurare il disco di avvio.

  5. Nella scheda Immagini pubbliche, scegli la versione 9 del sistema operativo Debian.

  6. Fai clic su Seleziona.

  7. Nella sezione Identità e accesso API, seleziona l'account di servizio che hai creato.

  8. Nella sezione Firewall, seleziona Consenti traffico HTTP.

  9. Fai clic sul pulsante Crea per creare l'istanza.

gcloud

Per creare un'istanza Compute, esegui il metodo gcloud compute instances create con le seguenti opzioni:

  • La ZONE selezionata al momento della creazione del cluster
  • Il tag http-server per consentire il traffico HTTP
  • La SERVICE_ACCOUNT che hai creato
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

L'output è simile al seguente esempio:

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

Potrebbe essere necessario un po' di tempo per l'avvio dell'istanza. Dopo l'avvio dell'istanza, è elencata nella pagina Istanze VM con un'icona di stato verde.

Per impostazione predefinita, l'istanza utilizza la stessa rete VPC predefinita utilizzata dal cluster, il che significa che il traffico può essere inviato dall'istanza al cluster.

Per connetterti all'istanza, completa i passaggi seguenti:

console

  1. Nella console, vai alla pagina Istanze VM.

    Vai alla pagina Istanze VM

  2. Nell'elenco delle istanze della macchina virtuale, fai clic su SSH nella riga dell'istanza che hai creato.

gcloud

Per connetterti all'istanza, esegui il comando gcloud compute ssh:

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

Ora hai una finestra terminale per l'interazione con la tua istanza Linux.

  1. Nella finestra del terminale, installa Netcat:

    sudo apt install netcat
    
  2. Scarica il file hl7v2-mllp-sample.txt e salvalo nell'istanza. Per informazioni sulla codifica e sui terminatori di segmento utilizzati nel file, vedi Separatori e codifica dei segmenti dei messaggi HL7v2.

  3. Per iniziare a inviare messaggi HL7v2 tramite l'adattatore MLLP al tuo archivio HL7v2, nella directory in cui hai scaricato il file, esegui questo comando. Utilizza il valore LoadBalancer Ingress visualizzato quando hai controllato il servizio.

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

    Dopo aver eseguito il comando, il messaggio viene inviato tramite l'adattatore MLLP al tuo archivio HL7v2. Se il messaggio è stato importato correttamente nell'archivio HL7v2, il comando restituisce il seguente output:

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

    Questo output indica che l'archivio HL7v2 ha risposto con un tipo di risposta AA (Application Accept), nel senso che il messaggio è stato convalidato e importato.

  4. Per visualizzare il messaggio pubblicato nell'argomento Pub/Sub, esegui il comando gcloud pubsub subscriptions pull:

    gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION
    

    Il comando restituisce il seguente output sul messaggio HL7v2 importato:

    ┌-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┐
    |                                                               DATA                                              |    MESSAGE_ID   |   ATTRIBUTES  |
    ├-----------------------------------------------------------------------------------------------------------------|-----------------|---------------|
    | projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/HL7V2_MESSAGE_ID | 123456789012345 | msgType=ADT   |
    └-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘
    
  5. Puoi anche elencare i messaggi nell'archivio HL7v2 per vedere se il messaggio è stato aggiunto:

    Curling

    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"
    

    Se la richiesta ha esito positivo, il server restituisce l'ID del messaggio in un percorso della risorsa:

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

    Se la richiesta ha esito positivo, il server restituisce l'ID del messaggio in un percorso della risorsa:

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

Dopo aver completato questa sezione, hai eseguito il deployment dell'adattatore MLLP in GKE e hai inviato un messaggio HL7v2 da un'istanza remota tramite l'adattatore e all'API Cloud Healthcare.

Nel resto del tutorial imparerai come criptare in modo sicuro i messaggi HL7v2 trasmessi configurando una VPN tra un'istanza di Compute Engine, che agisce come istanza "on-premise" e l'adattatore.

Configurazione di una VPN

La VPN consente di estendere la rete privata su cui invii messaggi HL7v2 attraverso una rete pubblica, ad esempio Internet. Utilizzando una VPN, puoi inviare messaggi dal tuo centro di assistenza attraverso l'adattatore MLLP e a Google Cloud. I sistemi in questo flusso agiscono come se fossero su un'unica rete privata.

Esistono due metodi per proteggere la connessione MLLP tramite VPN:

Configurazione di Cloud VPN

Cloud VPN connette in sicurezza la rete on-premise alla rete Virtual Private Cloud (VPC) di Google Cloud tramite una connessione VPN IPsec. Il traffico tra le due reti è criptato da un gateway VPN, quindi viene decriptato dall'altro gateway VPN. In questo modo i dati sono protetti mentre vengono trasferiti su Internet o su una rete di un centro di assistenza.

In questo tutorial, ciascun gateway VPN configurato si trova su una rete personalizzata e una subnet diverse in un'area geografica Google Cloud diversa.

Il gateway VPN configurato in us-central1 funge da gateway Cloud VPN sul lato Google Cloud, mentre il gateway Cloud VPN in europe-west1 simula il gateway "on-premise".

Riferimento per denominazioni e indirizzamento

Questo tutorial utilizza i seguenti nomi e indirizzi IP:

Lato Google Cloud

  • Nome rete: cloud-vpn-network
  • Nome subnet: subnet-us-central-10-0-1
  • Regione: us-central1
  • Intervallo di subnet: 10.0.1.0/24
  • Nome indirizzo IP esterno: cloud-vpn-ip
  • Nome gateway VPN: vpn-us-central
  • Nome del tunnel VPN: vpn-us-central-tunnel-1

"On-premise" lato

  • Nome rete: on-prem-vpn-network
  • Nome subnet: subnet-europe-west-10-0-2
  • Regione: europe-west1
  • Intervallo di subnet: 10.0.2.0/24
  • Nome indirizzo IP esterno: on-prem-vpn-ip
  • Nome gateway VPN: vpn-europe-west
  • Nome del tunnel VPN: vpn-europe-west-tunnel-1

Creazione di reti e subnet VPC personalizzate

Il primo passaggio della configurazione di Cloud VPN è creare due reti VPC. Una rete denominata on-prem-vpn-network è configurata nell'ambiente "on-premise" e viene eseguita su un'istanza VM di Compute Engine denominata on-prem-instance. L'altra rete, denominata cloud-vpn-network, è ciò che utilizza il cluster GKE che utilizza l'adattatore MLLP. Ti connetterai alla VM on-prem-instance e invierai messaggi HL7v2 all'adattatore MLLP in esecuzione sulla rete cloud-vpn-network tramite il bilanciatore del carico interno dell'adattatore MLLP.

Crea due reti VPC personalizzate e le relative subnet completando i seguenti passaggi:

  1. Per creare la prima rete VPC, cloud-vpn-network, esegui il comando seguente:

    gcloud compute networks create cloud-vpn-network \
       --project=PROJECT_ID \
       --subnet-mode=custom
    
  2. Per creare la subnet subnet-us-central-10-0-1 per la rete cloud-vpn-network, esegui il comando seguente:

    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. Per creare la rete VPC on-prem-vpn-network, esegui il comando seguente:

    gcloud compute networks create on-prem-vpn-network \
       --project=PROJECT_ID \
       --subnet-mode=custom
    
  4. Per creare la subnet subnet-europe-west-10-0-2 per la rete VPC on-prem-vpn-network, esegui il comando seguente:

    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
    

Creazione di un indirizzo IP esterno

Prima di creare i gateway VPN, prenotare un indirizzo IP esterno per ogni gateway completando i seguenti passaggi:

  1. Per prenotare un indirizzo IP esterno (statico) a livello di area geografica per l'indirizzo cloud-vpn-ip, esegui il comando seguente:

    gcloud compute addresses create cloud-vpn-ip \
       --project=PROJECT_ID \
       --region=us-central1
    
  2. Per prenotare un indirizzo IP esterno (statico) a livello di area geografica per l'indirizzo on-prem-vpn-ip, esegui il comando seguente:

    gcloud compute addresses create on-prem-vpn-ip \
       --project=PROJECT_ID \
       --region=europe-west1
    
  3. Prendi nota degli indirizzi IP esterni in modo da poterli utilizzare per configurare i gateway VPN nella sezione successiva. Per recuperare gli indirizzi IP esterni, esegui il comando seguente:

    Indirizzo IP Cloud VPN:

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

    "On-premise" Indirizzo IP VPN:

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

    I comandi restituiscono un output simile al seguente:

    address: 203.0.113.1
    

Creazione di gateway, tunnel e route VPN

Completa i passaggi seguenti per creare il gateway VPN, il tunnel e la route per Cloud VPN:

  1. Crea una chiave precondivisa (criptata) efficace seguendo le istruzioni in Generare una chiave precondivisa efficace. In questa sezione viene fatto riferimento a questa chiave come SHARED_SECRET.

  2. Per creare l'oggetto target VPN gateway, esegui il comando seguente:

    gcloud compute target-vpn-gateways create vpn-us-central \
       --project PROJECT_ID \
       --region us-central1 \
       --network cloud-vpn-network
    
  3. Per creare tre regole di forwarding, esegui i comandi seguenti, sostituendo la variabile CLOUD_VPN_EXTERNAL_ADDRESS con il valore dell'indirizzo IP di Cloud VPN nella sezione precedente:

    Invia il traffico ESP (IPsec) al gateway

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

    Invia il traffico UDP 500 al gateway

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

    Invia il traffico UDP 4500 al gateway

    gcloud compute forwarding-rules create vpn-us-central-rule-udp4500 \
        --project PROJECT_ID \
        --region us-central1 \
        --address CLOUD_VPN_EXTERNAL_ADDRESS \
        --ip-protocol UDP \
        --ports 4500 \
        --target-vpn-gateway vpn-us-central
    
  4. Per creare un tunnel nel gateway Cloud VPN, esegui il comando seguente. Sostituisci ON_PREM_VPN_IP con il valore dell'indirizzo "On-premise" VPN nella sezione precedente.

    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. Per creare una route statica verso 10.0.2.0/24, esegui il comando seguente:

    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"
    

Completa i passaggi seguenti per creare il gateway VPN, il tunnel e la route per la VPN "on-premise":

  1. Per creare l'oggetto target VPN gateway, esegui il comando seguente:

    gcloud compute target-vpn-gateways create "vpn-europe-west" \
       --project PROJECT_ID \
       --region "europe-west1" \
       --network "on-prem-vpn-network"
    
  2. Per creare tre regole di forwarding, esegui i comandi seguenti, sostituendo la variabile ON_PREMISES_VPN_EXTERNAL_ADDRESS con il valore dell'indirizzo IP "On-premise della sezione precedente:

    Invia il traffico ESP (IPsec) al gateway

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

    Invia il traffico UDP 500 al gateway

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

    Invia il traffico UDP 4500 al gateway

    gcloud compute forwarding-rules create vpn-europe-west-rule-udp4500 \
         --project PROJECT_ID \
         --region europe-west1 \
         --address ON_PREMISES_VPN_EXTERNAL_ADDRESS \
         --ip-protocol UDP \
         --ports 4500 \
         --target-vpn-gateway vpn-europe-west
    
  3. Per creare un tunnel nel gateway "on-premise", esegui il comando seguente:

    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. Per creare una route statica verso 10.0.1.0/24, esegui il comando seguente:

    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"
    

Hai creato i gateway Cloud VPN e "on-premise" e avviato i relativi tunnel. I gateway VPN non si connettono finché non crei regole firewall per consentire il traffico nel tunnel tra di loro.

Creazione di regole firewall

Devi creare le regole firewall per entrambi i lati del tunnel VPN. Queste regole consentono a tutto il traffico TCP, UDP e ICMP in entrata dalla subnet su un lato del tunnel VPN all'altro.

  1. Per creare le regole firewall per la subnet Cloud VPN, esegui il comando seguente:

    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. Per creare le regole firewall per la subnet "on-premise"", esegui il comando seguente:

    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. Crea una regola firewall che ti consenta di connetterti all'istanza VM sulla porta 22 tramite SSH: esegui il seguente comando:

    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
    

Verifica dello stato del tunnel VPN

Per verificare che il tunnel sia attivo, procedi nel seguente modo:

  1. Vai alla pagina VPN nella console.

    Vai alla pagina VPN

  2. Fai clic sulla scheda Tunnel Google VPN.

  3. Nel campo Stato di ogni tunnel, cerca un segno di spunta verde e la parola "Stabilito". Se questi elementi sono presenti, i tuoi gateway hanno negoziato un tunnel. Se dopo alcuni minuti non viene visualizzato alcun segno, consulta la sezione Risoluzione dei problemi.

    Per ulteriori informazioni di logging relative ai tunnel VPN, consulta la sezione Verifica dei log VPN nella pagina per la risoluzione dei problemi. Ad esempio, puoi visualizzare le metriche relative a pacchetti interrotti, stato del tunnel, byte ricevuti e byte inviati.

Ora che hai configurato Cloud VPN con i gateway, i tunnel e le regole firewall necessarie, puoi creare una connessione sicura tra l'istanza VM "on-premise" e l'adattatore MLLP in esecuzione su GKE.

Combinazione di deployment in GKE e Cloud VPN

Mentre in precedenza in questo tutorial hai testato localmente l'adattatore MLLP e inviato messaggi HL7v2 su una connessione non VPN all'adattatore MLLP, ora invierai i messaggi da una VM di Compute Engine tramite una connessione sicura tramite Cloud VPN all'adattatore MLLP in esecuzione su GKE. I messaggi vengono quindi inoltrati a un archivio HL7v2.

Nuova creazione del deployment

Innanzitutto, ricrea il deployment su GKE in modo che il cluster utilizzi le impostazioni configurate in Configurazione di Cloud VPN:

  1. Per eliminare il cluster mllp-adapter che hai creato, esegui il comando gcloud container clusters delete. Inserisci il valore COMPUTE_ZONE che hai utilizzato quando hai creato il cluster.

    gcloud container clusters delete mllp-adapter --zone=COMPUTE_ZONE
    
  2. Segui i passaggi in Deployment dell'adattatore MLLP in Kubernetes Engine, ma quando crei il cluster in GKE, aggiungi la rete cloud-vpn-network e la subnet subnet-us-central-10-0-1 creata in Creazione di reti e subnet VPN personalizzate.

    Assicurati che il comando di creazione del cluster abbia il seguente aspetto:

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

    dove:

    • COMPUTE_ZONE è la zona in cui viene eseguito il deployment del cluster. Quando hai configurato Cloud VPN nella sezione precedente, imposta la rete "GCP{/2}per utilizzare us-central1. Questa rete "lato GCP" è l'esecuzione del cluster GKE. Utilizza una delle seguenti zone in us-central1: us-central1-c, us-central1-a, us-central1-f, us-central1-b.

    • CLIENT_EMAIL è l'identificatore dell'account di servizio. Puoi trovarlo nel file della chiave dell'account di servizio nel campo "client_email":. Il formato è SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.

Creazione di una nuova VM di Compute Engine con impostazioni di rete

I passaggi riportati di seguito mostrano come creare un'istanza VM Linux in Compute Engine mediante la console. A differenza della VM di Compute Engine creata, questa VM utilizza le impostazioni di rete "'on-premise' side" per comunicare con il cluster GKE tramite una VPN.

console

  1. Nella console, vai alla pagina Istanze VM.

    Vai alla pagina Istanze VM

  2. Fai clic su Crea istanza.

  3. Scegli un'Area geografica e una Zona per l'istanza che corrisponde alle impostazioni di rete "'on-premise' side": europe-west1 (Belgium) per l'Area geografica e europe-west1-b per la Zona.

  4. Nella sezione Disco di avvio, fai clic su Cambia per iniziare a configurare il disco di avvio.

  5. Nella scheda Immagini pubbliche, scegli la versione 9 del sistema operativo Debian.

  6. Fai clic su Seleziona.

  7. Nella sezione Identità e accesso API, seleziona l'account di servizio che hai creato.

  8. Nella sezione Firewall, seleziona Consenti traffico HTTP.

  9. Espandi la sezione Gestione, sicurezza, dischi, networking, single-tenancy.

  10. In Interfacce di rete nella scheda Networking, specifica i dettagli della rete per le impostazioni di rete "'on-premise' side":

    1. Nel campo Rete, seleziona on-prem-vpn-network.
    2. Nel campo Subnet, seleziona subnet-europe-west-10-0-2 (10.0.2.0/24).
  11. Fai clic sul pulsante Crea per creare l'istanza.

Potrebbe essere necessario un po' di tempo per l'avvio dell'istanza. Quando è pronto, è elencato nella pagina Istanze VM con un'icona di stato verde.

gcloud

Per creare un'istanza Compute, esegui il metodo gcloud compute instances create con le seguenti opzioni:

  • ZONE che corrisponde alle impostazioni di rete "'on-premise' side": europe-west1-b per la zona.
  • Consenti il traffico HTTP specificando il tag http-server
  • La SERVICE_ACCOUNT che hai creato
gcloud compute instances create COMPUTE_NAME \
   --project=PROJECT_ID
   --zone=ZONE
   --image-family=debian-9 \
   --tags=http-server,https-server
   --service-account=SERVICE_ACCOUNT

L'output è simile al seguente esempio:

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

Per connetterti all'istanza, completa i passaggi seguenti:

console

  1. Nella console, vai alla pagina Istanze VM.

    Vai alla pagina Istanze VM

  2. Nell'elenco delle istanze della macchina virtuale, fai clic su SSH nella riga dell'istanza che hai creato.

gcloud

Per connetterti all'istanza, esegui il comando gcloud compute ssh:

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

Ora hai una finestra terminale per l'interazione con la tua istanza Linux.

  1. Nella finestra del terminale, installa Netcat:

    sudo apt install netcat
    
  2. Scarica il file hl7v2-mllp-sample.txt e salvalo nell'istanza.

  3. Per iniziare a inviare messaggi HL7v2 tramite l'adattatore MLLP al tuo archivio HL7v2, nella directory in cui hai scaricato il file, esegui questo comando. Utilizza il valore LoadBalancer Ingress visualizzato quando hai controllato il servizio.

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

    Dopo aver eseguito il comando, il messaggio viene inviato tramite l'adattatore MLLP al tuo archivio HL7v2. Se il messaggio è stato importato correttamente nell'archivio HL7v2, il comando restituisce il seguente output:

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

    Questo output indica che l'archivio HL7v2 ha risposto con un tipo di risposta AA (Application Accept), pertanto il messaggio è stato convalidato e importato.

  4. Per visualizzare il messaggio pubblicato nell'argomento Pub/Sub, esegui il comando gcloud pubsub subscriptions pull:

    gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION
    

    Il comando restituisce il seguente output sul messaggio HL7v2 importato:

    ┌-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┐
    |                                                               DATA                                              |    MESSAGE_ID   |   ATTRIBUTES  |
    ├-----------------------------------------------------------------------------------------------------------------|-----------------|---------------|
    | projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/HL7V2_MESSAGE_ID | 123456789012345 | msgType=ADT   |
    └-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘
    
  5. Puoi anche elencare i messaggi nell'archivio HL7v2 per vedere se il messaggio è stato aggiunto:

    Curling

    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"
    

    Se la richiesta ha esito positivo, il server restituisce l'ID del messaggio in un percorso della risorsa:

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

    Se la richiesta ha esito positivo, il server restituisce l'ID del messaggio in un percorso risorsa:

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

Dopo aver completato questa sezione, hai eseguito il deployment dell'adattatore MLLP in GKE, e tramite una VPN, hai inviato in modo sicuro un messaggio HL7v2 da un'istanza "on-premise" mediante l'adattatore e all'API Cloud Healthcare.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, puoi rimuovere le risorse create su Google Cloud.

Elimina il progetto

Per eliminare il progetto che hai creato in questo tutorial, procedi nel seguente modo:

  1. Nella console, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto da eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Risolvere i problemi

Errori dell'adattatore

Dopo aver eseguito il deployment dell'adattatore MLLP in GKE, si è verificato un errore nell'adattatore.

Connection refused errore durante l'esecuzione locale

Quando testi l'adattatore MLLP localmente, si verifica l'errore Connection refused.

  • Questo errore si verifica per alcuni utenti di Mac OS. Anziché utilizzare il flag --network=host, utilizza -p 2575:2575. Inoltre, invece di impostare --receiver_ip=127.0.0.0, imposta --receiver_ip=0.0.0.0. Il comando dovrebbe avere questo aspetto:

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

could not find default credentials errore durante l'esecuzione locale

Quando testi l'adattatore MLLP localmente, si verifica l'errore healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials. See https://developers.google.com/accounts/docs/application-default-credentials for more information..

Questo errore si verifica quando l'adattatore non riesce a trovare le credenziali di Google Cloud. Prima di eseguire di nuovo il comando, prova a risolvere il problema:

Errori di autenticazione

Se si verificano errori di autenticazione durante il test dell'adattatore MLLP in locale che non sono coperte nel resto di questa sezione, esegui nuovamente il comando docker run e aggiungi il flag -v ~/.config:/root/.config alla fine del comando, come mostrato di seguito:

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