Istruzioni per la trasmissione di messaggi HL7v2 tramite TCP/IP utilizzando il protocollo MLLP (Minimo vario secondo livello). Per richiedere l'MLLP un'immagine che deve essere firmata da un attestatore, segui i passaggi Trasmissione di messaggi HL7v2 su connessioni TCP/IP utilizzando un'immagine MLLP firmata.
Questo tutorial fornisce istruzioni per eseguire l'adattatore MLLP open source. ospitati 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
Dopo aver completato questo tutorial, saprai come:
- Crea e configura localmente l'adattatore MLLP con l'API Cloud Healthcare e testa invio di messaggi HL7v2 in un archivio HL7v2.
- Esegui il deployment dell'adattatore MLLP in GKE e invia messaggi HL7v2 da un'istanza VM di Compute Engine.
- Configurare una VPN che protegge la connessione tra un ambiente "on-premise" e MLLP e inviare messaggi HL7v2 dall'infrastruttura di Compute Engine.
Costi
In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:
- Cloud Healthcare API
- Google Kubernetes Engine
- Compute Engine
- Cloud VPN
- Pub/Sub
Per generare una stima dei costi basata sull'utilizzo previsto,
utilizza il Calcolatore prezzi.
Prima di iniziare
Prima di iniziare questo tutorial, acquisisci familiarità con le documentazione concettuale sul protocollo MLLP (Minimal Low Layer Protocol) esaminando MLLP e l'adattatore MLLP di Google Cloud. La documentazione concettuale fornisce una panoramica del MLLP, può inviare e ricevere messaggi da e verso l'API Cloud Healthcare tramite connessione MLLP e nozioni di base sulla sicurezza MLLP.
Prima di poter configurare l'adattatore MLLP, devi scegliere o creare un progetto Google Cloud e abilita le API richieste completando i seguenti passaggi 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.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
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.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
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 che l'API Kubernetes Engine e i servizi correlati siano abilitati. L'operazione può richiedere diversi minuti.
Scelta della shell
Per completare questo tutorial, puoi utilizzare Cloud Shell o shell locale.
Cloud Shell è un ambiente shell per la gestione delle risorse ospitate
su Google Cloud. Cloud Shell arriva
sono preinstallati con gcloud CLI
kubectl
lo strumento a riga di comando gcloud. gcloud CLI fornisce l'interfaccia a riga di comando principale
per Google Cloud. kubectl
offre l'interfaccia a riga di comando
sui cluster GKE.
Se preferisci utilizzare la tua shell locale, devi installare con gcloud CLI.
Per aprire Cloud Shell o configurare la tua shell locale, completa seguenti passaggi:
Cloud Shell
Per avviare Cloud Shell, completa questi passaggi:
Vai alla console Google Cloud.
Nell'angolo in alto a destra della console, fai clic su Attiva Google Pulsante Cloud Shell:
All'interno di un frame nella parte inferiore della console si apre una sessione di Cloud Shell. Tu
usa questa shell per eseguire i comandi gcloud
e kubectl
.
Shell locale
Per installare gcloud CLI e lo strumento kubectl
, completa la
seguenti passaggi:
- Installa e inizializza Google Cloud CLI.
-
Create local authentication credentials for your user account:
gcloud auth application-default login
Se per testare l'adattatore in locale, non devi completare altri passaggi e puoi continuare Creazione di un set di dati. Se esegui il deployment a 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 completando i seguenti 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 quanto segue:
- Un ID univoco nella sua 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 risiede definitivamente all'interno di una regione Google Cloud. Dopo il giorno selezionando, digita o seleziona la località nel campo Regione.
- Più regioni: il set di dati risiede definitivamente all'interno di una località che si estende in più regioni Google Cloud. Dopo aver selezionato, digita o seleziona la località multiregionale in il campo Multi-region.
- 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
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 un argomento Pub/Sub con il tuo archivio HL7v2. Per ulteriori informazioni, vedi Configurazione delle notifiche Pub/Sub.
Per creare un argomento, completa i seguenti passaggi:
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
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, completa i seguenti passaggi:
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 recapito impostata su Pull, quindi fai clic su Crea.
gcloud
Per creare una sottoscrizione, esegui
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 già avere ha creato un set di dati. Ai fini di questo tutorial, usa lo stesso progetto per il tuo archivio HL7v2 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 riesce, 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 riesce, 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 sull'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
Il giorno Pagina IAM nella console Google Cloud, verifica che il ruolo L'agente di servizio sanitario viene visualizzato nella colonna Ruolo per l'account di servizio del progetto pertinente. Il nome dell'account è service-PROJECT_NUMBER@gcp-sa-healthcare.iam.gserviceaccount.com. Per informazioni su come trovare 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 publisher Pub/Sub ruolo.
Seleziona il ruolo e fai clic su Salva. Il ruolo
pubsub.publisher
è è stato aggiunto all'account di servizio.
gcloud
Per aggiungere le autorizzazioni dell'account di servizio, esegui
gcloud projects add-iam-policy-binding
. Per informazioni su come trovare le PROJECT_ID e
PROJECT_NUMBER, vedi
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
Pull dell'immagine Docker predefinita in corso...
L'adattatore MLLP è un'applicazione containerizzata ospitata in un ambiente Docker predefinito 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 in locale, puoi configurarlo in modo che venga eseguito ricevitore, un editore o entrambi. Le configurazioni del destinatario e del publisher presentano le seguenti differenze fondamentali:
- Quando l’adattatore viene eseguito come ricevitore, riceve messaggi HL7v2 da un
sorgente esterna e chiamate
messages.ingest
di importare i messaggi in un archivio HL7v2, creando così un Notifica Pub/Sub. La notifica viene inviata a applicazioni sottoscritte al Pub/Sub dell'archivio HL7v2 per ogni argomento. - Quando l'adattatore viene eseguito come publisher, rimane in ascolto dei messaggi HL7v2 che sono
creato o importato in un archivio HL7v2 utilizzando
messages.create
omessages.ingest
. Una volta creato un messaggio, viene inviata una notifica Pub/Sub all'indirizzo l'adattatore e l'adattatore pubblicano i messaggi su un ricevitore esterno.
Le sezioni seguenti mostrano come eseguire l'adattatore in modo che agisca come ricevitore o un publisher.
Dopo aver verificato di poter eseguire l'adattatore MLLP sulla macchina locale, puoi passare alla sezione successiva 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, come un
da un centro assistenza, l'adattatore chiama
messages.ingest
e importa il messaggio HL7v2 nell'archivio HL7v2 configurato. Puoi
osservalo nel codice sorgente dell'adattatore.
Per testare l'adattatore localmente come ricevitore, completa i seguenti passaggi:
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 del progetto Google Cloud contenente il tuo archivio HL7v2.
- LOCATION è la regione in cui si trova il tuo archivio HL7v2.
- DATASET_ID è l'ID del set di dati padre del tuo archivio HL7v2.
- HL7V2_STORE_ID è l'ID dell'archivio HL7v2 a cui sei inviando messaggi HL7v2.
Dopo aver eseguito il comando precedente, l'adattatore stampa un messaggio simile a questo: il comando seguente e inizierà a essere eseguito sulla macchina locale all'indirizzo IP 127.0.0.1 Indirizzo 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.
In caso di errori, segui questi passaggi per la risoluzione dei problemi:
Se utilizzi Mac OS e il comando precedente non funziona e
Connection refused
errore, visualizza Errore di connessione rifiutata durante l'esecuzione in locale.Se il comando precedente ha esito negativo con un
healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials. See https://developers.google.com/accounts/docs/application-default-credentials for more information.
vedi l'errore Errorecould not find default credentials
durante l'esecuzione in locale.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 da un terminale diverso sul computer locale.
Nel nuovo terminale, per installare Netcat, esegui questo comando:
sudo apt install netcat
Scarica
hl7v2-mllp-sample.txt
e salvarlo sul computer locale.Per inviare il messaggio HL7v2 all'adattatore, nella directory scaricato il file, esegui questo comando. L'adattatore MLLP sta ascoltando 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 correttamente importato 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 è vengono convalidate e importate correttamente.Puoi anche verificare che il messaggio sia stato inviato correttamente aprendo dal terminale su cui hai fatto funzionare l'adattatore. L'output dovrebbe essere simile al nell'esempio seguente:
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 nell'archivio HL7v2, quindi è possibile chiamare
messages.list
per visualizzare il messaggio: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 riesce, il server restituisce l'ID del messaggio in un percorso di 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 riesce, il server restituisce l'ID del messaggio in un percorso di 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 in qualità di publisher, crei i messaggi chiamando
messages.create
oppure messages.ingest
e fornendo un file di messaggi come dati binari.
L'adattatore conferma automaticamente i messaggi Pub/Sub inviati
tramite messages.create
e messages.ingest
.
L'adattatore ti avvisa quando recupera e invia correttamente i messaggi Pub/Sub. L'adattatore è un Pub/Sub e il sottoscrittore, così riconosce automaticamente questi messaggi. Di conseguenza, vengono rimossi dalla coda dei messaggi in Pub/Sub configurato con l'adattatore.
Per eseguire il pull dalla sottoscrizione Pub/Sub e verificare separatamente che sono stati pubblicati i messaggi, devi creare un secondo Pub/Sub una sottoscrizione assegnata all'argomento che hai creato in precedenza. I messaggi inviati a il secondo abbonamento non viene confermato automaticamente dall'adattatore e persistenti in modo da poterli estrarre.
a 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 utilizzavi 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
creato in precedenza, esegui
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 in qualità di publisher, completa i seguenti passaggi sulla la macchina in cui hai eseguito il pull dell'immagine Docker predefinita:
Installa Netcat:
sudo apt install netcat
Scarica
hl7v2-mllp-ack-sample.txt
e salvarlo sul computer locale. Il file contiene un messaggio ACK che l'adattatore richiede come risposta quando tenta di pubblicare un messaggio.Per consentire a Netcat di ascoltare le connessioni in entrata sulla porta 2525, nel 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 all'esempio seguente visualizza:
listening on [any] 2525 ...
Netcat viene eseguito come processo in primo piano; pertanto, per continuare il test, apri un un terminale diverso sul computer locale.
Per avviare l'adattatore, esegui questo comando nel 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 il tuo archivio HL7v2.
- LOCATION è la regione in cui si trova il tuo archivio HL7v2.
- DATASET_ID è l'ID del set di dati padre del tuo archivio HL7v2.
- HL7V2_STORE_ID è l'ID dell'archivio HL7v2 a cui sei inviando messaggi HL7v2.
- PROJECT_ID è l'ID del progetto Google Cloud contenente l'argomento Pub/Sub.
- PUBSUB_SUBSCRIPTION è il nome del primo abbonamento che associato al tuo argomento Pub/Sub. La l'adattatore utilizza i messaggi di questa sottoscrizione e quindi per visualizzare i messaggi pubblicati nell'argomento devi eseguire il pull dei messaggi dalla seconda sottoscrizione che hai creato in precedenza.
Dopo aver eseguito il comando precedente, l'adattatore inizia a essere eseguito sul server all'indirizzo IP 127.0.0.1 sulla porta 2575.
In caso di errori, segui questi passaggi per la risoluzione dei problemi:
Se utilizzi Mac OS e il comando precedente non funziona e
Connection refused
errore, visualizza Errore di connessione rifiutata durante l'esecuzione in locale.Se il comando precedente ha esito negativo con un
healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials. See https://developers.google.com/accounts/docs/application-default-credentials for more information.
vedi l'errore Errorecould not find default credentials
durante l'esecuzione in locale.Se si verificano altri errori di autenticazione, consulta la sezione Errori di autenticazione.
L'adattatore viene eseguito come processo in primo piano; pertanto, per proseguire con i test, apri un un terminale diverso sul computer locale.
Scarica
hl7v2-sample.json
e salvarlo sul computer locale. Nella directory in cui hai scaricato il file il file, richiamamessages.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
- Nome dell'archivio HL7v2
- Un messaggio
- Un token di accesso
L'esempio seguente mostra una richiesta
POST
che utilizzacurl
e un file JSON di esempio chiamatahl7v2-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 riesce, 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
- Nome dell'archivio HL7v2
- Un messaggio
- Un token di accesso
L'esempio seguente 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 riesce, 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 una risposta simile a:
I0214 00:00:00.000000 1 healthapiclient.go:244] Started to fetch message from the Cloud Healthcare API HL7V2 Store I0214 00:00:00.000000 1 healthapiclient.go:283] Message was successfully fetched from the Cloud Healthcare API HL7V2 Store.
Nel terminale in cui hai eseguito Netcat, viene visualizzato un output simile al seguente di 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 al momento della creazione del messaggio. È uguale al valoredata
in il filehl7v2-sample.json
.per visualizzare il messaggio che l'adattatore ha pubblicato in 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. Prendi nota del valore
publish=true
nella colonnaATTRIBUTES
, che indica che il messaggio sia 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 destinatari esterni diversi
Puoi configurare l'archivio HL7v2 con più argomenti Pub/Sub e utilizzare i filtri per inviare notifiche a Pub/Sub diversi argomenti. Puoi quindi eseguire un adattatore MLLP per ogni argomento Pub/Sub per pubblicare i messaggi in un destinatario esterno diverso.
per configurare l'archivio HL7v2 con più Pub/Sub argomenti e un filtro per ciascun argomento, completa i seguenti passaggi:
Creare due argomenti Pub/Sub e una sottoscrizione per ogni argomento. Per ulteriori informazioni, consulta la sezione 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 riesce, 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 riesce, 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 nelle sezioni seguenti.
Configurazione e avvio del primo ricevitore e del primo adattatore
Per configurare e avviare il primo ricevitore e il primo adattatore, completa 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 l'hai ancora fatto. Il file contiene un messaggioACK
utilizzato come risposta da parte dell'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, in un 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 del progetto Google Cloud contenente il tuo archivio HL7v2.
- LOCATION è la regione in cui si trova il tuo archivio HL7v2.
- DATASET_ID è l'ID del set di dati padre del tuo archivio HL7v2.
- HL7V2_STORE_ID è l'ID dell'archivio HL7v2 a cui sei inviando messaggi HL7v2.
- PROJECT_ID è l'ID del progetto Google Cloud contenente l'argomento Pub/Sub.
- PUBSUB_SUBSCRIPTION è il nome del primo abbonamento che associato al tuo primo argomento Pub/Sub. L'adattatore utilizza i messaggi di questa sottoscrizione e automaticamente e li riconosce.
Dopo aver eseguito questo comando, l'adattatore inizia a essere eseguito su 127.0.0.1:2575. Pubblica nuovi al 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, completa 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 l'hai ancora fatto. Il file contiene un messaggioACK
utilizzato come risposta da parte dell'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, in un 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 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 il tuo archivio HL7v2.
- LOCATION è la regione in cui si trova il tuo archivio HL7v2.
- DATASET_ID è l'ID del set di dati padre del tuo archivio HL7v2.
- HL7V2_STORE_ID è l'ID dell'archivio HL7v2 a cui sei inviando messaggi HL7v2.
- PROJECT_ID è l'ID del 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 Pub/Sub. per ogni argomento. L'adattatore utilizza i messaggi di questa sottoscrizione la conferma automaticamente.
Dopo aver eseguito questo comando, l'adattatore inizia a essere eseguito sulla porta 127.0.0.1:2576 indirizzo IP. Pubblica nuovi al secondo ricevitore esterno sulla porta 2526.
Pubblicare un messaggio per il primo destinatario
Per creare un messaggio da pubblicare solo per il primo destinatario esterno, completa i seguenti passaggi:
Scarica
hl7v2-sample1.json
.Nella directory in cui hai scaricato
hl7v2-sample1.json
, chiama ilmessages.create
per creare il messaggio in un archivio HL7v2:curl
Per creare un messaggio HL7v2, effettua una richiesta
POST
e specifica quanto segue informazioni:- Il nome del set di dati padre
- Nome dell'archivio HL7v2
- Un messaggio
- Un token di accesso
L'esempio seguente mostra una richiesta
POST
che utilizzacurl
e un JSON di esempiohl7v2-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 riesce, 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 quanto segue informazioni:- Il nome del set di dati padre
- Nome dell'archivio HL7v2
- Un messaggio
- Un token di accesso
L'esempio seguente 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 riesce, 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 il valore La notifica Pub/Sub viene inviata solo alla prima Pub/Sub. Dopo aver creato il messaggio, la prima MLLP l'adattatore 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é viene inviata una notifica al secondo argomento Pub/Sub.
Nel terminale in cui hai eseguito il primo processo Netcat, l'output seguente vengono visualizzati i video. 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 al momento della creazione del messaggio. È uguale al valoredata
in il filehl7v2-sample1.json
.
Pubblicare un messaggio per il secondo destinatario
Per creare un messaggio da pubblicare solo per il secondo destinatario esterno: completa i seguenti passaggi:
Apri un nuovo terminale sulla tua macchina locale.
Per creare un messaggio da pubblicare solo nel secondo bucket esterno ricevitore, scarica
hl7v2-sample2.json
.Nella directory in cui hai scaricato
hl7v2-sample2.json
, chiama ilmessages.create
per creare il messaggio in un archivio HL7v2:curl
Per creare un messaggio HL7v2, effettua una richiesta
POST
e specifica quanto segue informazioni:- Il nome del set di dati padre
- Nome dell'archivio HL7v2
- Un messaggio
- Un token di accesso
L'esempio seguente mostra una richiesta
POST
che utilizzacurl
e un JSON di esempiohl7v2-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 riesce, 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
- Nome dell'archivio HL7v2
- Un messaggio
- Un token di accesso
L'esempio seguente 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 riesce, 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 sendFacility è
SEND_FACILITY_2
, perciò La notifica Pub/Sub viene inviata solo al secondo Pub/Sub. Dopo aver creato il messaggio, la prima 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, l'output seguente vengono visualizzati i video. 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 al momento della creazione del messaggio. È uguale al valoredata
in il filehl7v2-sample2.json
.
Deployment dell'adattatore MLLP in Google Kubernetes Engine
Quando si trasmettono messaggi HL7v2 tramite MLLP dal centro di assistenza sanitaria, una possibile è inviare i messaggi a un adattatore di cui viene eseguito il deployment Google Cloud e può inoltrarli all'API Cloud Healthcare.
L'adattatore MLLP funziona come applicazione stateless su un cluster GKE. Un cluster GKE è un cluster gestito di istanze VM per l'esecuzione di applicazioni containerizzate. stateless sono applicazioni che non archiviano dati o lo stato delle applicazioni cluster o verso l'archiviazione permanente dei dati. I dati e lo stato dell'applicazione rimangono invece nel client, rendendo le applicazioni stateless più scalabili.
GKE utilizza Deployment di deployment di applicazioni stateless in modo uniforme e non Pod. I deployment gestiscono lo stato desiderato dell'applicazione, ovvero il numero di pod devi eseguire l'applicazione, quale versione dell'immagine container deve eseguire gli elementi da etichettare dei pod e così via. Lo stato desiderato può essere è cambiato in modo dinamico grazie agli aggiornamenti Specifica del pod.
Allo stesso tempo in cui esegui il deployment dell'adattatore, crei un servizio Service che consente di connettere l'adattatore all'API Cloud Healthcare mediante il bilanciamento del carico interno.
Se non hai mai utilizzato GKE, devi completare Guida rapida di GKE per apprendere come funziona il prodotto.
Aggiunta delle autorizzazioni dell'API Pub/Sub all'account di servizio GKE
Come indicato nella documentazione di GKE su Autenticazione in piattaforma Cloud con account di servizio, ogni nodo in un cluster di container è un'istanza Compute Engine. Pertanto, quando l'adattatore MLLP viene eseguito su un cluster di container, eredita automaticamente gli ambiti delle istanze Compute Engine in cui viene eseguito il deployment.
Google Cloud crea automaticamente un account di servizio denominato "Account di servizio predefinito Compute Engine" e GKE associati con i nodi creati da GKE. A seconda di come è configurato il progetto, l'account di servizio predefinito potrebbe avere o meno le autorizzazioni per utilizzare le API Google Cloud. GKE assegna anche alcuni accessi gli ambiti alle istanze Compute Engine.
Per risultati ottimali, non autenticarti in altri servizi Google Cloud (ad esempio Pub/Sub) da Pod in esecuzione su GKE aggiornando il valore autorizzazioni o l'assegnazione di altri ambiti di accesso a Compute Engine di Compute Engine. Crea invece il tuo servizio Google Cloud.
Devi concedere le risorse Pub/Sub necessarie autorizzazioni al cluster di container, ma hai anche la possibilità concedendo le autorizzazioni di scrittura di metriche Cloud Monitoring.
Per creare un nuovo account di servizio che contenga solo gli ambiti che il container completa questi passaggi:
Console
Crea un account di servizio:
Nella console Google Cloud, vai alla pagina Crea account di servizio.
Seleziona un progetto.
Nel campo Nome account di servizio, inserisci un nome. La 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 o l'audiodescrizione.
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 di messaggi HL7v2 per il settore sanitario.
(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. Userai la finestra nel prossimo .
gcloud
Per creare l'account di servizio, esegui
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
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
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 viene eseguito il deployment del cluster. Una zona è una località regionale approssimativa
in cui risiedono i cluster e le relative risorse. Ad esempio,
us-west1-a
è in una zona della regioneus-west
. Se hai impostato una zona predefinita utilizzandogcloud config set compute/zone
, il valore di questo flag sostituisce il valore predefinito. - CLIENT_EMAIL è l'identificatore dell'account di servizio che ti interessa per l'utilizzo. Utilizza il formato SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.
Il comando restituisce un output simile all'esempio 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 Istanze VM di Compute Engine. Puoi verificarlo elencando le istanze con il seguente comando:
gcloud compute instances list
configura il deployment
Quando esegui il deployment di un'applicazione in GKE, devi definire le proprietà del deployment mediante un file manifest di deployment, che in genere è un file YAML. Per un esempio, vedi Creazione di un deployment.
Apri un terminale separato.
Con 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 del progetto Google Cloud contenente il tuo archivio HL7v2.
- LOCATION è la regione in cui si trova il tuo archivio HL7v2.
- DATASET_ID è l'ID del set di dati padre del tuo archivio HL7v2.
- HL7V2_STORE_ID è l'ID dell'archivio HL7v2 a cui sei 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 ogni pod, usate dal deployment per gestire i pod.spec: template: spec:
è il specifica del pod, che definisce il modo in cui deve essere eseguito ciascun pod.spec: containers
include il nome del container da eseguire in ogni pod, l'immagine container che dovrebbe essere eseguita.
Per ulteriori informazioni sulle specifiche del deployment, consulta Riferimento API Deployment.
Configurazione del servizio
rendere l'adattatore MLLP accessibile alle applicazioni al di fuori del cluster. ad esempio un centro assistenza, devi configurare un bilanciatore del carico interno.
Se non hai configurato una VPN, le applicazioni possono accedere all'adattatore MLLP attraverso il bilanciatore del carico interno purché le applicazioni usino lo stesso VPC e si trovano nella stessa regione Google Cloud. Ad esempio, per rendere l'adattatore accessibile a un Istanza VM nella stessa regione e sulla stessa rete VPC, potresti aggiungere un bilanciatore del carico interno del cluster Servizio risorsa.
Nella directory in cui hai creato il file manifest del deployment, usa
l'editor di testo per creare un file manifest del servizio denominato
mllp_adapter_service.yaml
con i seguenti contenuti. 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 casomllp-adapter-service
.metadata: annotations:
è un'annotazione che specifica che un carico interno è necessario configurare il bilanciatore.spec: type:
è il tipo di bilanciatore del carico.ports: port:
viene utilizzato per specificare la porta su cui il servizio può ricevere da altri servizi nello stesso cluster. La porta MLLP predefinita È in uso2575
.ports: targetPort:
viene utilizzato per specificare la porta su ciascun pod in cui viene utilizzato il servizio in esecuzione.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
),
può generare il proprio indirizzo IP a cui inviare
messaggi. Per ora, lascia che il cluster generi l'indirizzo IP, che
più avanti in questo tutorial.
Per ulteriori informazioni sul bilanciamento del carico interno, consulta GKE documentazione.
Per ulteriori informazioni sulla specifica del servizio, consulta Riferimento API di servizio.
Deployment del deployment
Per eseguire il deployment dell'adattatore in un cluster GKE, nella directory
contenente il file manifest del deployment mllp_adapter.yaml
, esegui questo
:
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 usare lo strumento kubectl
per esaminarlo.
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 avuto esito positivo, l'ultima parte dell'output della query 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, nella directory contenente
mllp_adapter_service.yaml
Nel file manifest del servizio, 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, ispezionalo 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
L'indirizzo IP LoadBalancer Ingress
potrebbe
la compilazione potrebbe richiedere fino a un minuto. Utilizzerai questo indirizzo IP
e alla 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 ha testato l'adattatore MLLP localmente e inviati messaggi HL7v2 al tuo 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, e le istanze esistenti devono essere nella stessa regione e utilizzano la stessa rete VPC.
Alla fine di questa sezione, troverai l'elenco delle notifiche pubblicate nel tuo l'argomento Pub/Sub e i messaggi HL7v2 nell'archivio HL7v2. La Per l'esecuzione dell'istanza VM di Compute Engine devono essere concesse le autorizzazioni queste attività. Prima di creare l'istanza, crea un nuovo account di servizio le autorizzazioni necessarie completando questi passaggi:
Console
Crea un account di servizio:
Nella console Google Cloud, vai alla pagina Crea account di servizio.
Seleziona un progetto.
Nel campo Nome account di servizio, inserisci un nome. La 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 o l'audiodescrizione.
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 > Consumatore messaggi HL7v2 Healthcare.
Fai clic su Continua.
Fai clic su Fine per completare la creazione dell'account di servizio.
Non chiudere la finestra del browser. Userai la finestra nel prossimo .
gcloud
Per creare l'account di servizio, esegui
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
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
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 che corrisponda alla zona selezionato quando hai creato il cluster. Per Ad esempio, se hai utilizzato
us-central1-a
per COMPUTE_ZONE quando hai creato il cluster, quindi nella schermata di creazione dell'istanza selezionaus-central1 (Iowa)
per la regione eus-central1-a
per il Zona:Nella sezione Disco di avvio, fai clic su Cambia per iniziare disco di avvio.
Nella scheda Immagini pubbliche, scegli la versione 9 di Debian un intero sistema operativo.
Fai clic su Seleziona.
Nella sezione Identità e accesso API, seleziona l'account di servizio è stato creato.
Nella sezione Firewall, seleziona Consenti traffico HTTP.
Fai clic sul pulsante Crea per creare l'istanza.
gcloud
Per creare un'istanza Compute, esegui
gcloud compute instances create
con le seguenti opzioni:
- Il ZONE che hai selezionato quando hai ha creato il cluster
- 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-10 \ --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, è elencato nella pagina delle istanze VM con un'icona di stato verde.
Per impostazione predefinita, l'istanza utilizza lo stesso rete VPC predefinita usato dal cluster, il che significa che il traffico può essere inviato dall'istanza nel cluster.
Per connetterti all'istanza, completa questi passaggi:
Console
Nella console Google Cloud, vai alla pagina Istanze VM.
Nell'elenco delle istanze di macchine virtuali, fai clic su SSH nella riga che hai creato.
gcloud
Per connetterti all'istanza, esegui
Comando gcloud compute ssh
:
gcloud compute ssh INSTANCE_NAME \ --project PROJECT_ID \ --zone ZONE
Ora hai una finestra del terminale per interagire con la tua istanza Linux.
Nella finestra del terminale, installa Netcat:
sudo apt install netcat
Scarica
hl7v2-mllp-sample.txt
e salvarlo nell'istanza. Per informazioni sulla codifica e sul segmento di terminazione utilizzati nel file, consulta Separatori e codifica dei segmenti di messaggi HL7v2.Per iniziare a inviare messaggi HL7v2 tramite l'adattatore MLLP all'archivio HL7v2, nella directory in cui hai scaricato il file, esegui questo comando: Utilizza il valore
LoadBalancer Ingress
visualizzato durante esaminato 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 a nel tuo archivio HL7v2. Se il messaggio è stato correttamente importato in HL7v2 store, 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
AA
(Application Accept
) di risposta, il che significa che il messaggio è stato convalidato e importato in modo corretto.Per visualizzare il messaggio pubblicato nell'argomento Pub/Sub, esegui il
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 è 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 riesce, il server restituisce dell'ID del messaggio in un percorso di 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 riesce, il server restituisce dell'ID del messaggio in un percorso di 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 a GKE e ha inviato un messaggio HL7v2 da un'istanza remota all'adattatore e all'API Cloud Healthcare.
Nel resto di questo tutorial imparerai a criptare in modo sicuro i file trasmessi i messaggi HL7v2 configurando una VPN tra un'istanza Compute Engine, che agisce da "on-premise" e l'adattatore.
Configurare una VPN
Usare una VPN consente di estendere la rete privata su cui si invia HL7v2 in una rete pubblica come internet. Utilizzando una VPN, puoi inviare i messaggi dal tuo centro assistenza tramite l'adattatore MLLP e in Google Cloud. I sistemi in questo flusso agiscono come se si trovassero su una singola rete privata.
Esistono due metodi per proteggere la connessione MLLP tramite VPN:
- Utilizzo di Cloud VPN
- Utilizzo di Strongswan su Docker soluzione VPN end-to-end
Configurazione di Cloud VPN
Cloud VPN connette in sicurezza la rete on-premise La rete Virtual Private Cloud (VPC) di Google Cloud tramite un Connessione VPN IPsec. Traffico stradale tra le due reti viene criptato da un gateway VPN, quindi viene decriptato da un altro gateway VPN. In questo modo i dati sono protetti mentre vengono trasferiti su internet attraverso la rete di un centro di assistenza sanitaria.
In questo tutorial, ogni gateway VPN configurato si trova su una una rete e una subnet personalizzate in un'altra regione Google Cloud.
Il gateway VPN configurato in us-central1
agisce come Cloud VPN
un gateway Cloud VPN ad alta disponibilità sul lato Google Cloud,
in europe-west1
simula i tuoi ambienti "on-premise" gateway VPN ad alta disponibilità.
Riferimento per denominazione e indirizzi
Come riferimento, in questo tutorial vengono utilizzati i seguenti nomi e indirizzi IP:
Lato Google Cloud
- Nome della 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 della 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 per la configurazione di Cloud VPN è creare due
Reti VPC. Una rete, chiamata on-prem-vpn-network
,
è configurato nella configurazione "on-premise" dell'ambiente di rete e viene eseguito
Istanza VM di Compute Engine denominata on-prem-instance
. L'altra rete,
chiamato cloud-vpn-network
, è ciò che il cluster GKE che esegue
dell'adattatore MLLP. Ti connetterai alla VM on-prem-instance
e invierai HL7v2
messaggi 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 rispettive subnet completando quanto segue 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
percloud-vpn-network
di rete, 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
peron-prem-vpn-network
rete VPC, 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 la VPN gateway, prenota un server esterno per ciascun gateway, completando i seguenti passaggi:
Per prenotare un indirizzo IP esterno (statico) a livello di regione per
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
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 la configurazione i gateway VPN nella prossima sezione. 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)'
"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 seguenti passaggi per creare il gateway, il tunnel e la route VPN per Cloud VPN:
Crea una chiave precondivisa efficace con crittografia (segreto condiviso) seguendo le istruzioni in Generazione di 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 questi comandi, sostituendo CLOUD_VPN_EXTERNAL_ADDRESS con il valore della variabile 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 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 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 della variabile "On-premise" Indirizzo IP della 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
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 i cluster "on-premise" VPN:
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 questi comandi, sostituendo ON_PREMISES_VPN_EXTERNAL_ADDRESS con la variabile dal valore "On-premise" Indirizzo IP VPN 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 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 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
Creare un tunnel nell'ambiente "on-premise" gateway VPN ad alta disponibilità, esegui questo :
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 Cloud VPN e "on-premise" gateway Cloud VPN e ha avviato la propria tunnel. I gateway VPN non si connetteranno finché non avrai creato le regole firewall e consentire il traffico attraverso il tunnel.
Creazione delle regole firewall in corso...
Devi creare regole firewall per entrambi i lati del tunnel VPN. Queste regole consenti a tutto il traffico TCP, UDP e ICMP di entrare dalla subnet su un lato del tunnel VPN all'altro.
Per creare le regole firewall per la subnet Cloud VPN, esegui seguente 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
Creare le regole firewall per l'infrastruttura "on-premise" subnet, esegui seguente 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 accedere tramite SSH all'istanza VM sulla porta 22 esegui 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, completa i seguenti passaggi:
Vai alla pagina VPN nella console Google Cloud.
Fai clic sulla scheda Tunnel VPN di Google.
Nel campo Status (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 appare alcun segno, vedi Risoluzione dei problemi.
Per ulteriori informazioni sul logging relative ai tunnel VPN, consulta Controllare i log della VPN nella pagina Risoluzione dei problemi. Per Ad esempio, puoi visualizzare le metriche relative ai pacchetti eliminati, allo stato del tunnel byte ricevuti e byte inviati.
Ora che hai configurato correttamente Cloud VPN con le risorse gateway, tunnel e regole firewall, puoi creare una connessione sicura tra i cluster "on-premise" un'istanza VM e l'adattatore MLLP in esecuzione con GKE.
Combinazione del deployment con GKE e Cloud VPN
mentre in precedenza ha testato l'adattatore MLLP localmente e inviato messaggi HL7v2 tramite una connessione non VPN all'adattatore MLLP, Ora invierai messaggi da una VM di Compute Engine tramite un sistema una connessione tramite Cloud VPN all'adattatore MLLP in esecuzione con GKE. I messaggi vengono quindi inoltrati a un archivio HL7v2.
Ricreare il deployment
Innanzitutto, ricrea il deployment su GKE in modo che il cluster utilizza le impostazioni che hai configurato Configurazione di Cloud VPN:
Per eliminare il cluster
mllp-adapter
che hai creato, esegui ilgcloud 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 in Deployment dell'adattatore MLLP in Kubernetes Engine, ma quando crei il cluster in GKE, aggiungi la rete
cloud-vpn-network
esubnet-us-central-10-0-1
subnet che hai creato 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, imposti il "lato Google Cloud" per utilizzare
us-central1
. Questo "lato Google Cloud" è la rete su cui viene eseguito il cluster GKE. Utilizza una delle seguenti zone inus-central1
:us-central1-c
,us-central1-a
,us-central1-f
eus-central1-b
.CLIENT_EMAIL è l'identificatore dell'account di servizio che ti interessa per l'utilizzo. Utilizza 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 utilizzando la console Google Cloud. A differenza del VM Compute Engine che hai creato, questa VM utilizza "'on-premise'" laterale" impostazioni di rete per comunicare con il cluster GKE tramite 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 corrisponda alla "'on-premise'" " impostazioni di rete:
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 la rete i dettagli per "'on-premise'" " impostazioni della rete:
- 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 è pronto, viene elencato sulla pagina Istanze VM, con un'icona di stato verde.
gcloud
Per creare un'istanza Compute, esegui
gcloud compute instances create
con le seguenti opzioni:
- Il valore ZONE che corrisponde alla
"'on-premise'" laterale"
impostazioni di rete:
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-10 \ --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 questi passaggi:
Console
Nella console Google Cloud, vai alla pagina Istanze VM.
Nell'elenco delle istanze di macchine virtuali, fai clic su SSH nella riga che hai creato.
gcloud
Per connetterti all'istanza, esegui
Comando gcloud compute ssh
:
gcloud compute ssh INSTANCE_NAME \ --project PROJECT_ID \ --zone ZONE
Ora hai una finestra del terminale per interagire con la tua istanza Linux.
Nella finestra del terminale, installa Netcat:
sudo apt install netcat
Scarica
hl7v2-mllp-sample.txt
e salvarlo nell'istanza.Per iniziare a inviare messaggi HL7v2 tramite l'adattatore MLLP all'archivio HL7v2, nella directory in cui hai scaricato il file, esegui questo comando: Utilizza il valore
LoadBalancer Ingress
visualizzato durante esaminato 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 a nel tuo archivio HL7v2. Se il messaggio è stato correttamente importato in HL7v2 store, 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
AA
Tipo di risposta (Application Accept
), che indica che il messaggio è stato convalidato e importati correttamente.Per visualizzare il messaggio pubblicato nell'argomento Pub/Sub, esegui il
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 è 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 riesce, il server restituisce dell'ID del messaggio in un percorso di 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 riesce, il server restituisce l'ID del messaggio in un percorso di 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 a GKE e, tramite una VPN, ha inviato in modo sicuro un messaggio HL7v2 da "on-premise" tramite l'adattatore e all'API Cloud Healthcare.
Esegui la pulizia
Per evitare che al tuo account Google Cloud vengano addebitati costi per usate in questo tutorial, puoi eseguire la pulizia delle risorse che hai creato in Google Cloud.
Elimina il progetto
Segui questi passaggi per eliminare il progetto che hai creato in questo tutorial:
- In the Google Cloud console, go to the Manage resources page.
- In the project list, select the project that you want to delete, and then click Delete.
- In the dialog, type the project ID, and then click Shut down to delete the project.
Risoluzione dei problemi
Errori dell'adattatore
Dopo aver eseguito il deployment dell'adattatore MLLP in GKE, l'adattatore rileva un errore.
- Segui i passaggi in Risoluzione dei 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 localmente,
riscontra l'errore Connection refused
.
Questo errore si verifica con alcuni utenti di Mac OS. Invece di utilizzare
--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 deve ha 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 in locale
Quando testi l'adattatore MLLP localmente,
riscontra l'errore
healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials.
.
Questo errore si verifica quando l'adattatore non riesce a trovare il rilevatore locale Credenziali ADC. Assicurati di avere configurare le credenziali predefinite dell'applicazione nel tuo ambiente locale.
Errori di autenticazione
Se riscontri errori di autenticazione durante il test locale dell'adattatore MLLP
non trattati nel resto di questa sezione, esegui nuovamente docker run
e aggiungi il flag -v ~/.config:/root/.config
alla fine del comando,
in questo modo:
docker run \
-v ~/.config:/root/.config \
...