Questo tutorial fornisce istruzioni per la trasmissione di messaggi HL7v2 su connessioni TCP/IP utilizzando il protocollo MLLP (minimo livello inferiore). Per richiedere che l'immagine MLLP venga firmata da un attestatore, segui la procedura descritta in Trasmettere messaggi HL7v2 su connessioni TCP/IP utilizzando un'immagine MLLP firmata.
Questo tutorial fornisce istruzioni per eseguire l'adattatore MLLP open source ospitato in GitHub nei seguenti ambienti:
- A livello locale/on-premise.
- In un container su GKE con Cloud VPN.
- In un container su GKE senza Cloud VPN.
Obiettivi
Al termine di questo tutorial, saprai come:
- Crea e configura localmente l'adattatore MLLP con l'API Cloud Healthcare e testa l'invio di messaggi HL7v2 a un archivio HL7v2.
- Esegui il deployment dell'adattatore MLLP su GKE e invia messaggi HL7v2 da un'istanza VM di Compute Engine.
- Configura una VPN che protegge la connessione tra un'istanza "on-premise" e l'adattatore MLLP e invia messaggi HL7v2 dall'istanza "on-premise".
Costi
In questo documento vengono utilizzati 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.
Prima di iniziare
Prima di iniziare questo tutorial, acquisisci familiarità con la documentazione concettuale sul protocollo MLLP (minimo livello inferiore), esaminando MLLP e l'adattatore MLLP di Google Cloud. La documentazione concettuale offre una panoramica di MLLP, di come i sistemi di assistenza possono inviare e ricevere messaggi da e verso l'API Cloud Healthcare tramite una connessione MLLP e le nozioni di base sulla sicurezza MLLP.
Prima di poter configurare l'adattatore MLLP, devi scegliere o creare un progetto Google Cloud e abilitare le API richieste seguendo questi passaggi:
- 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.
-
Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Abilita le API Cloud Healthcare API, Google Kubernetes Engine, Container Registry, and Pub/Sub.
-
Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Abilita le API Cloud Healthcare API, Google Kubernetes Engine, Container Registry, and Pub/Sub.
- Attendi l'abilitazione dell'API Kubernetes Engine e dei relativi servizi. Questa operazione può richiedere alcuni 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 ospitate
su Google Cloud. In Cloud Shell sono preinstallati gcloud CLI e lo strumento kubectl
. gcloud CLI fornisce la principale interfaccia a riga di comando
per Google Cloud. kubectl
fornisce l'interfaccia a riga di comando per
l'esecuzione di comandi sui cluster GKE.
Se preferisci utilizzare la tua shell locale, devi installare gcloud CLI.
Per aprire Cloud Shell o configurare la shell locale, completa questi passaggi:
Cloud Shell
Per avviare Cloud Shell, completa i seguenti passaggi:
Vai alla console Google Cloud.
Nell'angolo in alto a destra della console, fai clic sul pulsante Attiva Google Cloud Shell:
All'interno di un frame nella parte inferiore della console si apre una sessione di Cloud Shell. Puoi utilizzare questa shell per eseguire i comandi gcloud
e kubectl
.
Shell locale
Per installare gcloud CLI e lo strumento kubectl
, completa questi passaggi:
- Installa e inizializza Google Cloud CLI.
Se stai testando l'adattatore solo a livello locale, non devi completare altri passaggi e puoi passare alla creazione di un set di dati. Se esegui 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 ancora creato un set di dati dell'API Cloud Healthcare, crea un set di dati completando questi passaggi:
Console
- Nella console Google Cloud, vai alla pagina Set di dati.
- Fai clic su Crea set di dati.
-
Nel campo Nome, inserisci un identificatore per il set di dati. L'ID del set di dati deve avere i seguenti valori:
- Un ID univoco nella relativa posizione
- Una stringa Unicode da 1 a 256 caratteri composta da quanto segue:
- Numeri
- Lettere
- Trattini bassi
- Trattini
- Punti
-
Nella sezione Tipo di località, scegli uno dei seguenti tipi di località:
- Regione: il set di dati si trova in modo permanente all'interno di una regione Google Cloud. Dopo aver selezionato, digita o seleziona la località nel campo Regione.
- Più regioni: il set di dati si trova in modo permanente all'interno di una singola località che copre più regioni Google Cloud. Dopo aver selezionato, digita o seleziona la località a più regioni nel campo Più regioni.
- Fai clic su Crea.
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 e di una sottoscrizione Pub/Sub
Per ricevere notifiche quando i messaggi vengono creati o importati, devi configurare un argomento Pub/Sub con il tuo archivio HL7v2. Per ulteriori informazioni, consulta Configurazione delle notifiche Pub/Sub.
Per creare un argomento:
Console
Vai alla pagina Argomenti di Pub/Sub nella console Google Cloud.
Fai clic su Crea argomento.
Inserisci un nome per l'argomento con il seguente URI:
projects/PROJECT_ID/topics/TOPIC_NAME
dove PROJECT_ID è l'ID progetto Google Cloud.
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
Vai alla pagina Argomenti di Pub/Sub nella console Google Cloud.
Fai clic su un argomento del progetto.
Fai clic su Crea sottoscrizione.
Inserisci un nome per la sottoscrizione:
projects/PROJECT_ID/subscriptions/SUBSCRIPTION_NAME
Lascia l'opzione Tipo di consegna impostata su Pull, quindi fai clic su Crea.
gcloud
Per creare una sottoscrizione, 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
Crea un archivio HL7v2 e configuralo con un argomento Pub/Sub. Per creare un archivio HL7v2, devi già aver creato un set di dati. Ai fini di questo tutorial, utilizza lo stesso progetto per l'archivio HL7v2 e per l'argomento Pub/Sub.
Per creare un archivio HL7v2 configurato con un argomento Pub/Sub, completa i seguenti passaggi:
curl
curl -X POST \ --data "{ 'notificationConfigs': [ { 'pubsubTopic': 'projects/PROJECT_ID/topics/PUBSUB_TOPIC', 'filter': '' } ] }" \ -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \ -H "Content-Type: application/json; charset=utf-8" \ "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores?hl7V2StoreId=HL7V2_STORE_ID"
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 un messaggio HL7v2 viene creato o importato, devi configurare le autorizzazioni Pub/Sub nell'API Cloud Healthcare. Questo passaggio deve essere eseguito una volta per progetto.
Per aggiungere il ruolo pubsub.publisher
richiesto all'account di servizio del progetto, completa i seguenti passaggi:
Console
Nella pagina IAM della console Google Cloud, verifica che il ruolo Agente di servizio Healthcare venga 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 su come trovare l'oggetto PROJECT_NUMBER, consulta Identificazione dei progetti.
Fai clic sull'icona a forma di matita nella colonna Eredità corrispondente al ruolo. Viene visualizzato il riquadro Modifica autorizzazioni.
Fai clic su Aggiungi un altro ruolo e cerca il ruolo Publisher Pub/Sub.
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 Identificazione dei progetti.
gcloud projects add-iam-policy-binding PROJECT_ID \ --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-healthcare.iam.gserviceaccount.com \ --role=roles/pubsub.publisher
Esegui il pull dell'immagine Docker predefinita
L'adattatore MLLP è un'applicazione containerizzata in un'immagine Docker predefinita in Container Registry.
Per eseguire il pull della 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 a livello locale, puoi configurarlo in modo che venga eseguito come destinatario, un publisher o entrambi. Le configurazioni ricevitore e publisher presentano le seguenti differenze fondamentali:
- Quando l'adattatore viene eseguito come destinatario, riceve i 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 sottoscritte all'argomento Pub/Sub dell'archivio HL7v2. - Quando l'adattatore viene eseguito come publisher, rimane in ascolto dei messaggi HL7v2 creati o importati in un archivio HL7v2 utilizzando
messages.create
omessages.ingest
. Dopo la creazione di un messaggio, viene inviata una notifica Pub/Sub all'adattatore e quest'ultimo pubblica i messaggi su un destinatario esterno.
Le seguenti sezioni spiegano come eseguire l'adattatore in modo che agisca da ricevitore o da editore.
Dopo aver verificato di poter eseguire l'adattatore MLLP sulla tua macchina locale, puoi passare alla sezione successiva relativa al deployment dell'adattatore MLLP in Google Kubernetes Engine.
Testare l'adattatore MLLP localmente come ricevitore
Quando l'adattatore riceve un messaggio HL7v2 da un'origine esterna, ad esempio un centro sanitario, chiama messages.ingest
e importa il messaggio HL7v2 nell'archivio HL7v2 configurato. Puoi osservarlo nel codice sorgente dell'adattatore.
Per testare l'adattatore localmente come ricevitore, procedi nel seguente modo:
Sulla macchina in cui hai eseguito il pull dell'immagine Docker predefinita, esegui questo comando:
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 per il progetto Google Cloud contenente il tuo archivio HL7v2.
- LOCATION è la regione in cui si trova il tuo negozio HL7v2.
- DATASET_ID è l'ID del set di dati padre del tuo archivio HL7v2.
- HL7V2_STORE_ID è l'ID per l'archivio HL7v2 a cui si stanno inviando messaggi HL7v2.
Dopo aver eseguito il comando precedente, l'adattatore stampa un messaggio simile al seguente e viene 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 verificano errori, segui questi passaggi per la risoluzione dei problemi:
Se stai utilizzando Mac OS e il comando precedente non riesce e viene visualizzato un errore
Connection refused
, consulta Errore di connessione rifiutata durante l'esecuzione in locale.Se il comando precedente non riesce e restituisce un errore
healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials. See https://developers.google.com/accounts/docs/application-default-credentials for more information.
, consulta Errorecould not find default credentials
durante l'esecuzione localmente.Se si verificano altri errori di autenticazione, consulta la sezione Errori di autenticazione.
Per continuare con i test mentre l'adattatore è in esecuzione come processo in primo piano, apri un terminale diverso sulla macchina locale.
Nel nuovo terminale, per installare Netcat esegui questo comando:
sudo apt install netcat
Scarica il file
hl7v2-mllp-sample.txt
e salvalo sulla tua macchina locale.Per inviare il messaggio HL7v2 all'adattatore, nella directory in cui hai scaricato il file, esegui il comando seguente. L'adattatore MLLP è in ascolto sull'host locale sulla porta 2575. Il comando invia il messaggio tramite l'adattatore MLLP all'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
), il che significa che il messaggio è stato convalidato e importato correttamente.Puoi anche verificare che il messaggio sia stato inviato correttamente aprendo il terminale in cui hai eseguito l'adattatore. L'output dovrebbe essere simile al seguente esempio:
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.
Il messaggio è archiviato nel tuo archivio HL7v2, quindi puoi chiamare
messages.list
per visualizzarlo:curl
curl -X GET \ -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \ -H "Content-Type: application/json; charset=utf-8" \ "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages"
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" } ] }
Testare l'adattatore MLLP a livello locale come publisher
Quando testi l'adattatore come publisher, puoi creare i messaggi chiamando
messages.create
o messages.ingest
e fornendo un file dei messaggi 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 messaggi Pub/Sub. L'adattatore è un abbonato Pub/Sub, quindi conferma automaticamente questi messaggi. Di conseguenza, vengono rimossi dalla coda dei messaggi nell'abbonamento Pub/Sub che hai configurato con l'adattatore.
Per eseguire il pull dalla sottoscrizione Pub/Sub e verificare separatamente che i messaggi sono stati pubblicati, devi creare una seconda sottoscrizione Pub/Sub assegnata all'argomento creato in precedenza. I messaggi inviati al secondo abbonamento non vengono riconosciuti automaticamente dall'adattatore e vengono mantenuti per poter essere pull.
Per creare una seconda sottoscrizione Pub/Sub assegnata all'argomento creato in precedenza, completa i seguenti passaggi:
Console
Vai alla pagina Argomenti di Pub/Sub nella console Google Cloud.
Fai clic su un argomento del progetto. Questo è l'argomento che hai utilizzato per creare la sottoscrizione iniziale.
Fai clic su Crea sottoscrizione.
Inserisci un nome per la sottoscrizione:
projects/PROJECT_ID/subscriptions/SECOND_SUBSCRIPTION_NAME
Lascia Tipo di consegna impostato su Pull.
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 in locale come publisher, completa i seguenti passaggi sulla macchina in cui hai eseguito il pull dell'immagine Docker predefinita:
Installa Netcat:
sudo apt install netcat
Scarica il file
hl7v2-mllp-ack-sample.txt
e salvalo sulla tua macchina locale. Il file contiene un messaggio ACK che l'adattatore richiede come risposta quando tenta di pubblicare un messaggio.Per consentire a Netcat di rimanere in ascolto delle connessioni in entrata sulla porta 2525, nella directory in cui hai scaricato il file, esegui questo comando.
Linux
echo -n -e "\x0b$(cat hl7v2-mllp-ack-sample.txt)\x1c\x0d" | nc -q1 -lv -p 2525 | less
Dopo l'avvio di Netcat, viene visualizzato un messaggio di output simile al seguente esempio:
listening on [any] 2525 ...
Netcat viene eseguito come processo in primo piano, quindi per continuare il test, apri un terminale diverso sulla macchina locale.
Per avviare l'adattatore, nel nuovo terminale esegui questo comando:
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 per il progetto Google Cloud contenente il tuo archivio HL7v2.
- LOCATION è la regione in cui si trova il tuo negozio HL7v2.
- DATASET_ID è l'ID del set di dati padre del tuo archivio HL7v2.
- HL7V2_STORE_ID è l'ID per l'archivio HL7v2 a cui si stanno inviando messaggi HL7v2.
- PROJECT_ID è l'ID del progetto Google Cloud contenente l'argomento Pub/Sub.
- PUBSUB_SUBSCRIPTION è il nome della prima sottoscrizione creata associata all'argomento Pub/Sub. L'adattatore consuma i messaggi di questa sottoscrizione e li conferma automaticamente, quindi per visualizzare i messaggi pubblicati nell'argomento devi estrarre i messaggi dal secondo abbonamento creato in precedenza.
Dopo aver eseguito il comando precedente, l'adattatore inizia a essere eseguito sulla macchina locale all'indirizzo IP 127.0.0.1 sulla porta 2575.
Se si verificano errori, segui questi passaggi per la risoluzione dei problemi:
Se stai utilizzando Mac OS e il comando precedente non riesce e viene visualizzato un errore
Connection refused
, consulta Errore di connessione rifiutata durante l'esecuzione in locale.Se il comando precedente non riesce e restituisce un errore
healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials. See https://developers.google.com/accounts/docs/application-default-credentials for more information.
, consulta Errorecould not find default credentials
durante l'esecuzione localmente.Se si verificano altri errori di autenticazione, consulta la sezione Errori di autenticazione.
L'adattatore viene eseguito come processo in primo piano, quindi per continuare il test, apri un altro terminale sulla macchina locale.
Scarica il file
hl7v2-sample.json
e salvalo sulla tua macchina locale. Nella directory in cui hai scaricato il file, chiama il metodomessages.create
per creare il messaggio in un archivio HL7v2:curl
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
Il seguente esempio mostra una richiesta
POST
mediantecurl
e un file JSON di esempio denominatohl7v2-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
Il seguente esempio mostra una richiesta
POST
mediante Windows PowerShell e un file JSON di esempio denominatohl7v2-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.
Nel terminale in cui hai eseguito Netcat, viene visualizzato un output simile al seguente esempio. 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|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 nel campo
data
della risposta che hai ricevuto quando hai creato il messaggio. È uguale al valoredata
nel filehl7v2-sample.json
.Per visualizzare il messaggio pubblicato dall'adattatore nell'argomento Pub/Sub, esegui il comando
gcloud pubsub subscriptions pull
nella 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. Prendi nota del valore
publish=true
nella colonnaATTRIBUTES
, 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 per ricevitori 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 in un ricevitore esterno diverso.
Per configurare l'archivio HL7v2 con più argomenti Pub/Sub e un filtro per ogni argomento, completa la procedura seguente:
Creare due argomenti Pub/Sub e una sottoscrizione per ogni argomento. Per ulteriori informazioni, consulta la sezione sulla creazione di un argomento e di una sottoscrizione Pub/Sub.
Esegui questo comando:
curl
curl -X PATCH \ -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \ -H "Content-Type: application/json; charset=utf-8" \ --data "{ 'notificationConfigs': [ { 'pubsubTopic': 'projects/PROJECT_ID/topics/PUBSUB_TOPIC', 'filter' : 'sendFacility=\"SEND_FACILITY_1\"' }, { 'pubsubTopic': 'projects/PROJECT_ID/topics/SECOND_PUBSUB_TOPIC', 'filter': 'sendFacility=\"SEND_FACILITY_2\"' } ] }" "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID?updateMask=notificationConfigs"
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 testare il routing dei messaggi, completa i passaggi indicati nelle sezioni seguenti.
Configurazione e avvio del primo ricevitore e del primo adattatore
Per configurare e avviare il primo ricevitore e l'adattatore, svolgi i seguenti passaggi:
Sulla macchina in cui hai eseguito il pull dell'immagine Docker predefinita, esegui questo comando per installare Netcat:
sudo apt install netcat
Scarica
hl7v2-mllp-ack-sample.txt
, se non lo hai ancora fatto. Il file contiene un messaggioACK
utilizzato come risposta dall'adattatore quando tenta di pubblicare un messaggio.Per impostare la porta 2525 per il primo ricevitore, esegui questo 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 ...
Per avviare il primo adattatore, esegui questo 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 per il progetto Google Cloud contenente il tuo archivio HL7v2.
- LOCATION è la regione in cui si trova il tuo negozio HL7v2.
- DATASET_ID è l'ID del set di dati padre del tuo archivio HL7v2.
- HL7V2_STORE_ID è l'ID per l'archivio HL7v2 a cui si stanno inviando messaggi HL7v2.
- PROJECT_ID è l'ID del progetto Google Cloud contenente l'argomento Pub/Sub.
- PUBSUB_SUBSCRIPTION è il nome della prima sottoscrizione creata associata al tuo primo argomento Pub/Sub. L'adattatore consuma i messaggi di questa sottoscrizione e li conferma automaticamente.
Dopo aver eseguito questo comando, l'adattatore inizia a essere eseguito sulla macchina locale il giorno 127.0.0.1:2575. Pubblica nuovi messaggi sul primo ricevitore esterno sulla porta 2525.
Configurazione e avvio del secondo ricevitore e dell'adattatore
Per configurare e avviare il secondo ricevitore e l'adattatore, svolgi i seguenti passaggi:
Sulla macchina in cui hai eseguito il pull dell'immagine Docker predefinita, esegui questo comando per installare Netcat:
sudo apt install netcat
Scarica
hl7v2-mllp-ack-sample.txt
, se non lo hai ancora fatto. Il file contiene un messaggioACK
utilizzato come risposta dall'adattatore quando tenta di pubblicare un messaggio.Per impostare la porta 2526 per il secondo ricevitore, esegui questo comando.
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 ...
Per avviare il secondo adattatore, esegui questo 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 per il progetto Google Cloud contenente il tuo archivio HL7v2.
- LOCATION è la regione in cui si trova il tuo negozio HL7v2.
- DATASET_ID è l'ID del set di dati padre del tuo archivio HL7v2.
- HL7V2_STORE_ID è l'ID per l'archivio HL7v2 a cui si stanno inviando messaggi HL7v2.
- PROJECT_ID è l'ID del progetto Google Cloud contenente l'argomento Pub/Sub.
- SECOND_PUBSUB_SUBSCRIPTION è il nome del secondo abbonamento creato e associato al secondo argomento Pub/Sub. L'adattatore consuma i messaggi di questa sottoscrizione e li conferma automaticamente.
Dopo aver eseguito questo comando, l'adattatore viene avviato sulla macchina locale sulla porta 127.0.0.1:2576 dell'indirizzo IP. Pubblica nuovi messaggi sul secondo ricevitore esterno sulla porta 2526.
Pubblicazione di un messaggio per il primo destinatario
Per creare un messaggio che verrà pubblicato solo per il primo destinatario esterno, completa i seguenti passaggi:
Scarica
hl7v2-sample1.json
.Nella directory in cui hai scaricato
hl7v2-sample1.json
, chiama il metodomessages.create
per creare il messaggio in un archivio HL7v2:curl
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
Il seguente esempio mostra una richiesta
POST
mediantecurl
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
Il seguente esempio mostra una richiesta
POST
mediante Windows PowerShell e un file JSON di esempio denominatohl7v2-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 suSEND_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 nel campo
data
della risposta che hai ricevuto quando hai creato il messaggio. È uguale al valoredata
nel filehl7v2-sample1.json
.
Pubblicazione di un messaggio per il secondo destinatario
Per creare un messaggio che verrà pubblicato solo per il secondo destinatario esterno, completa i seguenti passaggi:
Apri un nuovo terminale sulla macchina locale.
Per creare un messaggio che sarà pubblicato solo per il secondo destinatario esterno, scarica
hl7v2-sample2.json
.Nella directory in cui hai scaricato
hl7v2-sample2.json
, chiama il metodomessages.create
per creare il messaggio in un archivio HL7v2:curl
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
Il seguente esempio mostra una richiesta
POST
mediantecurl
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
Il seguente esempio mostra una richiesta
POST
mediante 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 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 nel campo
data
della risposta che hai ricevuto quando hai creato il messaggio. È uguale al valoredata
nel filehl7v2-sample2.json
.
Deployment dell'adattatore MLLP in Google Kubernetes Engine
Quando trasmetti messaggi HL7v2 tramite MLLP dal tuo centro sanitario, una possibile configurazione è quella di inviare i messaggi a un adattatore di cui è stato eseguito il deployment in Google Cloud e di 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 i dati o lo stato delle applicazioni nel cluster o nell'archiviazione permanente. I dati e lo stato delle applicazioni rimangono invece nel client, il che rende più scalabili le applicazioni stateless.
GKE utilizza il controller Deployment per eseguire il deployment di applicazioni stateless come pod uniformi e non unici. I deployment gestiscono lo stato desiderato dell'applicazione: quanti pod devono eseguire l'applicazione, quale versione dell'immagine container devono essere eseguiti, quali pod devono essere etichettati e così via. Lo stato desiderato può essere modificato in modo dinamico tramite gli aggiornamenti alla specifica del pod del deployment.
Contemporaneamente a eseguire il deployment dell'adattatore, puoi creare un controller di servizio che ti consente di collegarlo 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 dell'API Pub/Sub all'account di servizio GKE
Come indicato nella documentazione di GKE sull'autenticazione in piattaforma Cloud 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 è stato eseguito il deployment.
Google Cloud crea automaticamente un account di servizio denominato "Account di servizio predefinito Compute Engine" e GKE associa questo account di servizio ai nodi creati da GKE. A seconda di come è configurato il tuo 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 limitato alle istanze di Compute Engine.
Per ottenere risultati ottimali, non eseguire l'autenticazione in 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.
Devi concedere le autorizzazioni Pub/Sub necessarie al cluster di container, ma hai anche la possibilità di concedere le autorizzazioni per scrivere metriche in Cloud Monitoring.
Per creare un nuovo account di servizio contenente solo gli ambiti richiesti dal cluster di container, completa i passaggi seguenti:
Console
Crea un account di servizio:
Nella console Google Cloud, vai alla pagina Crea account di servizio.
Seleziona un progetto.
Inserisci un nome nel campo Nome account di servizio. La console Google Cloud compila il campo ID account di servizio in base a questo nome.
(Facoltativo) Nel campo Descrizione account di servizio, inserisci una descrizione.
Fai clic su Crea.
Fai clic sul campo Seleziona un ruolo.
In Tutti i ruoli, fai clic su Pub/Sub > Sottoscrittore Pub/Sub.
Fai clic su Aggiungi un altro ruolo e poi sul campo Seleziona un ruolo.
In Tutti i ruoli, fai clic su Cloud Healthcare > Importazione messaggi HL7v2 Healthcare.
(Facoltativo) Se vuoi abilitare il monitoraggio, fai clic su Aggiungi un altro ruolo, quindi fai clic sul campo Seleziona un ruolo.
In Tutti i ruoli, fai clic su Monitoring > Monitoring Metric Writer.
Fai clic su Continua.
Fai clic su Fine per completare la creazione dell'account di servizio.
Non chiudere la finestra del browser. Utilizzerai la finestra nella procedure successiva.
Crea una chiave dell'account di servizio:
Nella console Google Cloud, fai clic sull'indirizzo email dell'account di servizio che hai creato.
Fai clic su Chiavi.
Fai clic su Aggiungi chiave, quindi su Crea nuova chiave.
Fai clic su Crea. Sul computer viene scaricato un file della chiave JSON.
Fai clic su Chiudi.
gcloud
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.
Per concedere ciascun 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
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 eseguire 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]
Creazione del 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 è stato 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 nella regioneus-west
. Se hai impostato una zona predefinita utilizzandogcloud config set compute/zone
, il valore di questo flag sostituisce quello predefinito. - 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 esempio:
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. Puoi verificarlo elencando le istanze con il seguente comando:
gcloud compute instances list
Configurazione del deployment
Quando esegui il deployment di un'applicazione in GKE, definisci le proprietà del deployment utilizzando un file manifest del deployment, che in genere è un file YAML. Per un esempio, consulta la sezione Creazione di un deployment.
Apri un terminale separato.
Utilizzando un editor di testo, crea un file manifest di deployment denominato
mllp_adapter.yaml
con i seguenti contenuti:
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 per il progetto Google Cloud contenente il tuo archivio HL7v2.
- LOCATION è la regione in cui si trova il tuo negozio HL7v2.
- DATASET_ID è l'ID del set di dati padre del tuo archivio HL7v2.
- HL7V2_STORE_ID è l'ID per l'archivio HL7v2 a cui si stanno inviando 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 il deployment utilizza per gestire i pod.spec: template: spec:
è la specifica del pod, che definisce la modalità di esecuzione di ogni pod.spec: containers
include il nome del container da eseguire in ogni pod e l'immagine container che deve essere eseguita.
Per ulteriori informazioni sulla specifica del deployment, consulta il riferimento per l'API Deployment.
Configurazione del servizio
Per rendere l'adattatore MLLP accessibile alle applicazioni esterne al cluster (come un centro assistenza), 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 regione di Google Cloud. Ad esempio, per rendere l'adattatore accessibile a un'istanza VM di Compute Engine nella stessa regione e nella stessa rete VPC, puoi aggiungere un bilanciatore del carico interno alla risorsa Servizio del cluster.
Nella directory in cui hai creato il file manifest del 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 scegli per il Servizio. In questo caso, èmllp-adapter-service
.metadata: annotations:
è un'annotazione che specifica che è necessario configurare un bilanciatore del carico interno.spec: type:
è il tipo di bilanciatore del carico.ports: port:
viene utilizzato per specificare la porta su cui il servizio può ricevere il traffico da altri servizi nello stesso cluster. Viene utilizzata la porta MLLP predefinita di2575
.ports: targetPort:
viene utilizzato per specificare la porta su ogni pod su cui è in esecuzione il servizio.spec: selector: app:
specifica i pod scelti come target dal servizio.
Sebbene sia possibile specificare un indirizzo IP per il bilanciatore del carico (utilizzando il campo clusterIP
), il bilanciatore del carico può generare il proprio indirizzo IP a cui è possibile inviare messaggi. Per ora consenti al cluster di generare l'indirizzo IP, che userai
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 per l'API dei servizi.
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 questo comando:
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 ha esito positivo, l'ultima parte dell'output del comando precedente deve 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, nella directory contenente il file manifest del servizio mllp_adapter_service.yaml
, esegui questo comando:
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, controllalo per verificare che sia stato configurato correttamente.
Per ispezionare il bilanciatore del carico interno, esegui questo comando:
kubectl describe service mllp-adapter-service
L'output del comando è simile all'esempio seguente:
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
Il completamento 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 in locale e hai inviato messaggi HL7v2 al tuo archivio HL7v2, ora invierai 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 le istanze esistenti devono trovarsi nella stessa regione e utilizzare la stessa rete VPC.
Alla fine di questa sezione, elencherai le notifiche pubblicate nell'argomento Pub/Sub e i messaggi HL7v2 nell'archivio HL7v2. All'istanza VM di Compute Engine devono essere concesse le autorizzazioni per eseguire queste attività. Prima di creare l'istanza, crea un nuovo account di servizio con le autorizzazioni richieste completando i seguenti passaggi:
Console
Crea un account di servizio:
Nella console Google Cloud, vai alla pagina Crea account di servizio.
Seleziona un progetto.
Inserisci un nome nel campo Nome account di servizio. La console Google Cloud compila il campo ID account di servizio in base a questo nome.
(Facoltativo) Nel campo Descrizione account di servizio, inserisci una descrizione.
Fai clic su Crea.
Fai clic sul campo Seleziona un ruolo.
In Tutti i ruoli, fai clic su Pub/Sub > Sottoscrittore Pub/Sub.
Fai clic su Aggiungi un altro ruolo e poi sul campo Seleziona un ruolo.
In Tutti i ruoli, fai clic su Cloud Healthcare > Healthcare HL7v2 Message Consumer.
Fai clic su Continua.
Fai clic su Fine per completare la creazione dell'account di servizio.
Non chiudere la finestra del browser. Utilizzerai la finestra nella procedure successiva.
Crea una chiave dell'account di servizio:
Nella console Google Cloud, fai clic sull'indirizzo email dell'account di servizio che hai creato.
Fai clic su Chiavi.
Fai clic su Aggiungi chiave, quindi su Crea nuova chiave.
Fai clic su Crea. Sul computer viene scaricato un file della chiave JSON.
Fai clic su Chiudi.
gcloud
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.
Per concedere ciascun 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
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
Nella console Google Cloud, vai alla pagina Istanze VM.
Fai clic su Crea istanza.
Scegli una regione e una zona per l'istanza corrispondente alla zona selezionata quando hai creato il cluster. Ad esempio, se hai utilizzato
us-central1-a
per COMPUTE_ZONE quando hai creato il cluster, nella schermata di creazione dell'istanza selezionaus-central1 (Iowa)
per Regione eus-central1-a
per Zona.Nella sezione Disco di avvio, fai clic su Cambia per iniziare a configurare il disco di avvio.
Nella scheda Immagini pubbliche, scegli la versione 9 del sistema operativo Debian.
Fai clic su Seleziona.
Nella sezione Identità e accesso API, seleziona l'account di servizio che hai creato.
Nella sezione Firewall, seleziona Consenti traffico HTTP.
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:
- ZONE che hai selezionato quando hai creato il cluster
- Il tag
http-server
per consentire il traffico HTTP - 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. Una volta avviata, l'istanza viene 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 seguenti passaggi:
Console
Nella console Google Cloud, vai alla pagina Istanze VM.
Nell'elenco delle istanze di macchine virtuali, 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
Viene visualizzata una finestra terminale per interagire con l'istanza Linux.
Nella finestra del terminale, installa Netcat:
sudo apt install netcat
Scarica il file
hl7v2-mllp-sample.txt
e salvalo nell'istanza. Per informazioni sulla codifica e sui terminatori di segmento utilizzati nel file, consulta Separatori e codifica dei segmenti del messaggio HL7v2.Per iniziare a inviare messaggi HL7v2 tramite l'adattatore MLLP all'archivio HL7v2, nella directory in cui hai scaricato il file, esegui il comando seguente. Utilizza il valore di
LoadBalancer Ingress
che è stato visualizzato al momento dell'ispezione del 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 all'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
), il che significa che il messaggio è stato convalidato e importato correttamente.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 | └-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘
Puoi anche elencare i messaggi nel tuo archivio HL7v2 per vedere se il messaggio è stato aggiunto:
curl
curl -X GET \ -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \ -H "Content-Type: application/json; charset=utf-8" \ "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages"
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 attraverso l'adattatore e all'API Cloud Healthcare.
Nel resto di questo tutorial imparerai a criptare in modo sicuro i messaggi HL7v2 trasmessi configurando una VPN tra un'istanza di Compute Engine, che funge da istanza "on-premise", e l'adattatore.
Configurazione di una VPN
L'uso di una VPN consente di estendere la rete privata su cui si inviano messaggi HL7v2 attraverso una rete pubblica, come internet. Con una VPN, puoi inviare messaggi dal tuo centro di assistenza sanitaria tramite l'adattatore MLLP e a Google Cloud. I sistemi in questo flusso si comportano come se fossero su un'unica rete privata.
Esistono due metodi per proteggere la connessione MLLP tramite VPN:
- Utilizzare Cloud VPN
- Utilizzo della soluzione VPN end-to-end Strongswan su Docker
Configurazione di Cloud VPN
Cloud VPN collega in modo sicuro la rete on-premise alla rete Virtual Private Cloud (VPC) di Google Cloud tramite una connessione VPN IPsec. Il traffico tra le due reti viene criptato da un gateway VPN, quindi decriptato dall'altro gateway VPN. In questo modo i tuoi dati sono protetti mentre vengono trasferiti su internet o sulla rete di un centro di assistenza sanitaria.
In questo tutorial, ogni gateway VPN che configuri si trova su una rete e una subnet personalizzate diverse in una regione 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 l'assegnazione di nomi e indirizzi
Come riferimento, 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 tunnel VPN:
vpn-us-central-tunnel-1
Lato "On-premise"
- 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 tunnel VPN:
vpn-europe-west-tunnel-1
Creazione di reti e subnet VPC personalizzate
Il primo passaggio nella configurazione di Cloud VPN consiste nel creare due reti VPC. Una rete, denominata on-prem-vpn-network
,
è configurata nell'ambiente "on-premise" ed viene eseguita su
un'istanza VM di Compute Engine denominata on-prem-instance
. L'altra rete, denominata cloud-vpn-network
, è quella utilizzata dal cluster GKE che esegue l'adattatore MLLP. Ti connetterai alla VM on-prem-instance
e invierai i messaggi HL7v2
all'adattatore MLLP in esecuzione nella 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:
Per creare la prima rete VPC,
cloud-vpn-network
, esegui questo comando:gcloud compute networks create cloud-vpn-network \ --project=PROJECT_ID \ --subnet-mode=custom
Per creare la subnet
subnet-us-central-10-0-1
per la retecloud-vpn-network
, esegui questo comando: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
Per creare la rete VPC
on-prem-vpn-network
, esegui questo comando:gcloud compute networks create on-prem-vpn-network \ --project=PROJECT_ID \ --subnet-mode=custom
Per creare la subnet
subnet-europe-west-10-0-2
per la rete VPCon-prem-vpn-network
, esegui questo comando: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, prenota un indirizzo IP esterno per ciascun gateway svolgendo i seguenti passaggi:
Per prenotare un indirizzo IP esterno (statico) a livello di regione per l'indirizzo
cloud-vpn-ip
, esegui questo comando:gcloud compute addresses create cloud-vpn-ip \ --project=PROJECT_ID \ --region=us-central1
Per prenotare un indirizzo IP esterno (statico) a livello di regione per l'indirizzo
on-prem-vpn-ip
, esegui questo comando:gcloud compute addresses create on-prem-vpn-ip \ --project=PROJECT_ID \ --region=europe-west1
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 questo comando:
Indirizzo IP Cloud VPN:
gcloud compute addresses describe cloud-vpn-ip \ --project PROJECT_ID \ --region us-central1 \ --format='flattened(address)'
Indirizzo IP VPN"on-premise":
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 seguenti passaggi per creare il gateway, il tunnel e la route VPN per Cloud VPN:
Crea una chiave precondivisa efficace (secret condiviso) seguendo le istruzioni riportate in Generare una chiave precondivisa efficace. In questa sezione viene fatto riferimento a questa chiave come SHARED_SECRET.
Per creare l'oggetto gateway VPN di destinazione, esegui questo comando:
gcloud compute target-vpn-gateways create vpn-us-central \ --project PROJECT_ID \ --region us-central1 \ --network cloud-vpn-network
Per creare tre regole di forwarding, esegui i comandi seguenti, sostituendo la variabile CLOUD_VPN_EXTERNAL_ADDRESS con il valore dell'indirizzo IP 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
Per creare un tunnel nel gateway Cloud VPN, esegui questo comando. Sostituisci ON_PREM_VPN_IP con il valore dell'indirizzo IP VPN "On-premise" 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
Per creare una route statica verso
10.0.2.0/24
, esegui questo comando: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 seguenti passaggi per creare il gateway, il tunnel e la route VPN per la VPN "on-premise":
Per creare l'oggetto gateway VPN di destinazione, esegui questo comando:
gcloud compute target-vpn-gateways create "vpn-europe-west" \ --project PROJECT_ID \ --region "europe-west1" \ --network "on-prem-vpn-network"
Per creare tre regole di forwarding, esegui i comandi seguenti, sostituendo la variabile ON_PREMISES_VPN_EXTERNAL_ADDRESS con il valore dell'indirizzo IP VPN "on-premise" nella 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
Per creare un tunnel nel gateway "on-premise", esegui questo comando:
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
Per creare una route statica verso
10.0.1.0/24
, esegui questo comando: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 hai avviato i relativi tunnel. I gateway VPN non si connetteranno finché non avrai creato regole firewall per consentire il traffico attraverso il tunnel tra i due.
Creazione delle regole firewall in corso...
Devi creare regole firewall per entrambi i lati del tunnel VPN. Queste regole consentono a tutto il traffico TCP, UDP e ICMP in entrata dalla subnet da un lato all'altro del tunnel VPN.
Per creare le regole firewall per la subnet Cloud VPN, esegui questo comando:
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
Per creare le regole firewall per la subnet "on-premise", esegui questo comando:
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
Crea una regola firewall che ti consenta di connetterti tramite SSH all'istanza VM sulla porta 22 eseguendo questo 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
Controllo dello stato del tunnel VPN in corso...
Per verificare che il tunnel sia attivo, segui questi passaggi:
Vai alla pagina VPN nella console Google Cloud.
Fai clic sulla scheda Tunnel VPN Google.
Nel campo Stato di ogni tunnel, cerca un segno di spunta verde e la parola "Stabilito". Se questi elementi sono presenti, i gateway hanno negoziato un tunnel. Se dopo qualche minuto non viene visualizzato alcun segno, consulta la sezione Risoluzione dei problemi.
Per ulteriori informazioni sui log relativi ai tunnel VPN, consulta Controllo dei log della VPN nella pagina Risoluzione dei problemi. Ad esempio, puoi visualizzare le metriche relative ai pacchetti persi, allo stato del tunnel, ai byte ricevuti e inviati.
Ora che hai configurato correttamente Cloud VPN con i gateway, i tunnel e le regole firewall necessari, puoi creare una connessione sicura tra l'istanza VM "on-premise" e l'adattatore MLLP in esecuzione su GKE.
Combinazione del deployment in GKE e Cloud VPN
Mentre in precedenza in questo tutorial hai testato l'adattatore MLLP in locale e hai inviato messaggi HL7v2 all'adattatore MLLP tramite una connessione non VPN, ora invierai messaggi da una VM di Compute Engine tramite una connessione sicura utilizzando Cloud VPN all'adattatore MLLP in esecuzione su GKE. I messaggi vengono quindi inoltrati a un archivio HL7v2.
Ricreazione del deployment
Innanzitutto, ricrea il deployment su GKE in modo che il cluster utilizzi le impostazioni configurate in Configurazione di Cloud VPN:
Per eliminare il cluster
mllp-adapter
che hai creato, esegui il comandogcloud 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
Segui i passaggi descritti in Deployment dell'adattatore MLLP in Kubernetes Engine, ma quando crei il cluster in GKE, aggiungi la rete
cloud-vpn-network
e la subnetsubnet-us-central-10-0-1
creata nella sezione Creazione di reti e subnet VPN personalizzate.Assicurati che il comando di creazione del cluster sia simile al seguente:
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 è stato eseguito il deployment del cluster. Quando hai configurato Cloud VPN nella sezione precedente, hai impostato la rete "Lato Google Cloud" in modo da utilizzare
us-central1
. Questa rete "lato Google Cloud" è su cui viene eseguito il cluster GKE. Utilizza una delle seguenti zone inus-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":
. Prende il formato SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.
Creazione di una nuova VM di Compute Engine con impostazioni di rete
I passaggi seguenti mostrano come creare un'istanza di macchina virtuale Linux in Compute Engine utilizzando la console Google Cloud. A differenza della VM di Compute Engine che hai creato, questa VM utilizza le impostazioni di rete "lato on-premise" per comunicare con il cluster GKE su una VPN.
Console
Nella console Google Cloud, vai alla pagina Istanze VM.
Fai clic su Crea istanza.
Scegli una regione e una zona per l'istanza che corrispondono alle impostazioni di rete "lato 'on-premise'":
europe-west1 (Belgium)
per la regione eeurope-west1-b
per la zona.Nella sezione Disco di avvio, fai clic su Cambia per iniziare a configurare il disco di avvio.
Nella scheda Immagini pubbliche, scegli la versione 9 del sistema operativo Debian.
Fai clic su Seleziona.
Nella sezione Identità e accesso API, seleziona l'account di servizio che hai creato.
Nella sezione Firewall, seleziona Consenti traffico HTTP.
Espandi la sezione Gestione, sicurezza, dischi, networking, single-tenancy.
In Interfacce di rete nella scheda Networking, specifica i dettagli di rete per le impostazioni di rete "lato "on-premise":
- Nel campo Rete, seleziona on-prem-vpn-network.
- Nel campo Subnet, seleziona subnet-europe-west-10-0-2 (10.0.2.0/24).
Fai clic sul pulsante Crea per creare l'istanza.
Potrebbe essere necessario un po' di tempo per l'avvio dell'istanza. Quando è pronta, viene elencata 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 "lato 'on-premise':
europe-west1-b
per la zona. - Consenti il traffico HTTP specificando il tag
http-server
- 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 seguenti passaggi:
Console
Nella console Google Cloud, vai alla pagina Istanze VM.
Nell'elenco delle istanze di macchine virtuali, 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
Viene visualizzata una finestra terminale per interagire con l'istanza Linux.
Nella finestra del terminale, installa Netcat:
sudo apt install netcat
Scarica il file
hl7v2-mllp-sample.txt
e salvalo nell'istanza.Per iniziare a inviare messaggi HL7v2 tramite l'adattatore MLLP all'archivio HL7v2, nella directory in cui hai scaricato il file, esegui il comando seguente. Utilizza il valore di
LoadBalancer Ingress
che è stato visualizzato al momento dell'ispezione del 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 all'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
), il che significa che il messaggio è stato convalidato e importato correttamente.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 | └-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘
Puoi anche elencare i messaggi nel tuo archivio HL7v2 per vedere se il messaggio è stato aggiunto:
curl
curl -X GET \ -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \ -H "Content-Type: application/json; charset=utf-8" \ "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages"
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, su una VPN, hai inviato in modo sicuro un messaggio HL7v2 da un'istanza "on-premise" tramite 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 eseguire la pulizia delle risorse che hai creato su Google Cloud.
Elimina il progetto
Per eliminare il progetto creato in questo tutorial:
- Nella console Google Cloud, vai alla pagina Gestisci risorse.
- Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
- Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.
Risoluzione dei problemi
Errori dell'adattatore
Dopo il deployment dell'adattatore MLLP in GKE, l'adattatore riscontra un errore.
- Segui la procedura descritta in Risolvere i problemi relativi ai carichi di lavoro di cui è stato eseguito il deployment.
Connection refused
errore durante l'esecuzione in locale
Quando testi l'adattatore MLLP in locale, si verifica l'errore Connection refused
.
Questo errore si verifica con alcuni utenti di Mac OS. Anziché utilizzare il flag
--network=host
, usa-p 2575:2575
. Inoltre, invece di impostare--receiver_ip=127.0.0.0
, imposta--receiver_ip=0.0.0.0
. Il comando dovrebbe essere simile al seguente: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 in locale
Quando testi l'adattatore MLLP in locale, 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 Google Cloud. Per correggere l'errore, prova uno dei seguenti metodi prima di eseguire nuovamente il comando:
- Segui le istruzioni in Configurazione dell'autenticazione per le applicazioni di produzione server-to-server per verificare che l'adattatore possa trovare le tue credenziali Google Cloud.
- Installa e inizializza Google Cloud CLI per accedere a gcloud CLI. Assicurati di autorizzare gcloud CLI sulla macchina su cui stai testando l'adattatore localmente.
Errori di autenticazione
Se durante il test dell'adattatore MLLP in locale si verificano errori di autenticazione che non sono trattati nel resto di questa sezione, esegui nuovamente il comando docker run
e aggiungi il flag -v ~/.config:/root/.config
alla fine del comando, in questo modo:
docker run \
-v ~/.config:/root/.config \
...