Trasmissione di messaggi HL7v2 su connessioni TCP/IP

Questo tutorial fornisce istruzioni per la trasmissione di messaggi HL7v2 su connessioni TCP/IP utilizzando il protocollo MLLP (Minimal Lower Layer Protocol). Per richiedere la firma dell'immagine MLLP da parte di un attestatore, segui i passaggi descritti in Trasmissione di messaggi HL7v2 su connessioni TCP/IP utilizzando un'immagine MLLP firmata.

Questo tutorial fornisce istruzioni per l'esecuzione dell'adattatore MLLP open source in hosting su GitHub nei seguenti ambienti:

• Localmente/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:

• Compila e configura localmente l'adattatore MLLP con l'API Cloud Healthcare e testa l'invio di messaggi HL7v2 in un archivio HL7v2.
• Esegui il deployment dell'adattatore MLLP in GKE e invia messaggi HL7v2 da un'istanza VM Compute Engine.
• Configura una VPN che protegga la connessione tra un'istanza "on-premise" e l'adattatore MLLP e invia messaggi HL7v2 dall'istanza "on-premise".

Costi

In questo documento utilizzi 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. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Prima di iniziare

Prima di iniziare questo tutorial, acquisisci familiarità con la documentazione concettuale sul protocollo MLLP (Minimal Lower 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:

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the Cloud Healthcare API, Google Kubernetes Engine, Container Registry, and Pub/Sub APIs.

   Enable the APIs

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Make sure that billing is enabled for your Google Cloud project.

7. Enable the Cloud Healthcare API, Google Kubernetes Engine, Container Registry, and Pub/Sub APIs.

   Enable the APIs

8. Attendi che l'API Kubernetes Engine e i relativi servizi siano abilitati. L'operazione può richiedere diversi minuti.

Scegliere una 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 include l'interfaccia a riga di comando gcloud e lo strumento kubectl preinstallati. 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 shell locale, devi installare l'interfaccia a riga di comando gcloud.

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

Cloud Shell

Per avviare Cloud Shell, completa i seguenti passaggi:

1. Vai alla console Google Cloud.

   Console Google Cloud

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

Una sessione di Cloud Shell si apre in un frame nella parte inferiore della console. Tu usa questa shell per eseguire i comandi gcloud e kubectl.

Shell locale

Per installare gcloud CLI e lo strumento kubectl, completa i seguenti passaggi:

1. Installa e inizializza Google Cloud CLI.

2. If you're using a local shell, then create local authentication credentials for your user account:

   gcloud auth application-default login

   You don't need to do this if you're using Cloud Shell.

3. Se per testare l'adattatore localmente, non devi completare altri passaggi e puoi continuare Creazione di un set di dati. Se esegui il deployment dell'adattatore in GKE, installa lo strumento a riga di comando kubectl eseguendo il seguente 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

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

   Vai a Set di dati

2. Fai clic su Crea set di dati.
3. 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
4. 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.
   • Multi-regione: il set di dati risiede in modo permanente in una località che si estende su più regioni Google Cloud. Dopo aver selezionato, digita o seleziona la località multiregionale in il campo Multi-region.
5. 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 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

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

   Vai alla pagina degli argomenti Pub/Sub

2. Fai clic su Crea argomento.

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

   projects/PROJECT_ID/topics/TOPIC_NAME

   dove PROJECT_ID è l'ID progetto Google Cloud.

4. Fai clic su Crea.

gcloud

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

gcloud pubsub topics create projects/PROJECT_ID/topics/TOPIC_NAME

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

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

Per creare un abbonamento, completa i seguenti passaggi:

Console

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

   Vai alla pagina degli argomenti Pub/Sub

2. Fai clic su un argomento del progetto.

3. Fai clic su Crea sottoscrizione.

4. Inserisci un nome per la sottoscrizione:

   projects/PROJECT_ID/subscriptions/SUBSCRIPTION_NAME

5. Lascia Tipo di consegna impostato su Pull e 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

Nota: per configurare il numero di secondi di attesa del sistema conferma da parte del sottoscrittore prima di ritentare la consegna, utilizza flag --ack-deadline facoltativo. Senza questo flag, la scadenza predefinita è di 10 secondi.

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à avere ha 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"

Nota: in questo esempio, filter non è definito in modo che l'API Cloud Healthcare invii una notifica Pub/Sub per ogni messaggio creato o importato.

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

Nota: in questo esempio, filter non è definito in modo che l'API Cloud Healthcare invii una notifica Pub/Sub per ogni messaggio creato o importato.

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

1. 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 è [e-mail]. Per informazioni su come trovare PROJECT_NUMBER, consulta Identificazione dei progetti.

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

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

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

gcloud

Per aggiungere le autorizzazioni dell'account di servizio, esegui 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:[e-mail] \
    --role=roles/pubsub.publisher

Estrazione dell'immagine Docker predefinita

L'adattatore MLLP è un'applicazione containerizzata in fase di staging in un'immagine Docker predefinita in Container Registry.

Per eseguire il pull dell'ultima versione dell'immagine, esegui il seguente 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 come ricevente, publisher 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, ascolta i messaggi HL7v2 che sono stati creati o importati in un archivio HL7v2 utilizzando messages.create o messages.ingest. Dopo aver creato un messaggio, viene inviata una notifica Pub/Sub all'adattatore, che pubblica i messaggi a un destinatario 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 tua macchina locale, puoi passare alla sezione successiva su Eseguire il 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 osservarlo nel codice sorgente dell'adattatore.

Per testare l'adattatore localmente come ricevitore, completa i seguenti passaggi:

1. Sulla macchina su cui hai eseguito il pull dell'immagine Docker predefinita, esegui il seguente 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 inviare 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 va a buon fine con un Connection refused errore, consulta Errore Connessione rifiutata durante l'esecuzione 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 Errore could not find default credentials durante l'esecuzione in locale.

   • Se si verificano altri errori di autenticazione, consulta la sezione Errori di autenticazione.

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

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

   sudo apt install netcat
   

4. Scarica hl7v2-mllp-sample.txt e salvarlo sul computer locale.

5. Per inviare il messaggio HL7v2 all'adattatore, esegui il seguente comando nella directory in cui hai scaricato il file. 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.

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

7. 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 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 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"
       }
     ]
   }
   

Testare l'adattatore MLLP in locale come publisher

Quando testi l'adattatore come publisher, crei i messaggi chiamando messages.create o 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 invia una notifica 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 nell'abbonamento Pub/Sub configurato con l'adattatore.

Per eseguire il pull dall'abbonamento Pub/Sub e verificare separatamente che i messaggi siano stati pubblicati, devi creare un secondo abbonamento Pub/Sub assegnato all'argomento creato in precedenza. I messaggi inviati al secondo abbonamento non vengono confermati automaticamente dall'adattatore e rimangono in modo da poterli recuperare.

Per creare una seconda sottoscrizione Pub/Sub assegnata all'argomento creato in precedenza:

Console

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

   Vai alla pagina degli argomenti Pub/Sub

2. Fai clic su un argomento del progetto. Si tratta dell'argomento utilizzato per creare l'iscrizione iniziale.

3. Fai clic su Crea sottoscrizione.

4. Inserisci un nome per la sottoscrizione:

   projects/PROJECT_ID/subscriptions/SECOND_SUBSCRIPTION_NAME

   Lascia Tipo di consegna impostato su Pull.

5. Fai clic su Crea.

gcloud

Per creare una seconda sottoscrizione Pub/Sub assegnata creato in precedenza, esegui gcloud pubsub subscriptions create :

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

Nota: per configurare il numero di secondi che il sistema deve attendere la conferma di ricezione da parte del sottoscrittore prima di riprovare a eseguire la consegna, utilizza il flag facoltativo --ack-deadline. Senza questo flag, la scadenza predefinita è 10 secondi.

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

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

Per testare l'adattatore localmente come publisher, completa i seguenti passaggi sulla macchina su cui hai eseguito il pull dell'immagine Docker precompilata:

1. Installa Netcat:

   sudo apt install netcat
   

2. Scarica il hl7v2-mllp-ack-sample.txt file e salvalo sul tuo computer locale. Il file contiene un messaggio ACK che l'adattatore richiede come risposta quando tenta di pubblicare un messaggio.

3. Per consentire a Netcat di ascoltare le connessioni in arrivo sulla porta 2525, esegui il seguente comando nella directory in cui hai scaricato il file.

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

4. Netcat viene eseguito come processo in primo piano, quindi per continuare con i test, apri un altro terminale sulla tua macchina locale.

5. Per avviare l'adattatore, esegui il seguente 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 stai inviando i 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. L'adattatore utilizza i messaggi di questa sottoscrizione e li conferma automaticamente, quindi per visualizzare i messaggi pubblicati nell'argomento devi estrarre i messaggi dalla seconda sottoscrizione creata in precedenza.

   Dopo aver eseguito il comando precedente, l'adattatore inizia a funzionare sulla tua 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 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 Errore could 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 sul computer locale.

6. Scarica hl7v2-sample.json e salvarlo sul computer locale. Nella directory in cui hai eseguito il download il file, richiama messages.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 principale
   • Il nome dell'archivio HL7v2
   • Un messaggio
   • Un token di accesso

   L'esempio seguente mostra una richiesta POST che utilizza curl e un file JSON di esempio chiamata hl7v2-sample.json

   curl -X POST \
        -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
        -H "Content-Type: application/json; charset=utf-8" \
        --data-binary @hl7v2-sample.json \
        "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages"

   Se la richiesta 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 principale
   • 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 denominato hl7v2-sample.json

   $cred = gcloud auth application-default print-access-token
   $headers = @{ Authorization = "Bearer $cred" }
   
   Invoke-WebRequest `
     -Method Post `
     -Headers $headers `
     -ContentType: "application/json; charset=utf-8" `
     -InFile hl7v2-sample.json `
     -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages" | Select-Object -Expand Content

   Se la richiesta 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 alla seguente:

   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.
   

7. Nel terminale in cui hai eseguito Netcat, viene visualizzato un output simile all'esempio seguente. 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 valore data in il file hl7v2-sample.json.

8. Per visualizzare il messaggio pubblicato dall'adattatore nell'argomento Pub/Sub, esegui il comando gcloud pubsub subscriptions pull sul secondo abbonamento 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 colonna ATTRIBUTES, 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 diversi argomenti Pub/Sub. Puoi quindi eseguire un'adattatore MLLP per ogni argomento Pub/Sub per pubblicare i messaggi in un destinatario esterno diverso.

Importante: pubblicazione di messaggi per destinatari esterni diversi e test richiede l'apertura di cinque terminali. Poiché il numero massimo di istanze di Cloud Shell è quattro, devi eseguire i passaggi in una shell locale.

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

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

2. 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\""
       }
     ]
   }
   

Testare il 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:

1. Sulla macchina in cui hai eseguito il pull dell'immagine Docker predefinita, esegui questo comando per installare Netcat:

   sudo apt install netcat
   

2. Scarica hl7v2-mllp-ack-sample.txt, se non l'hai ancora fatto. Il file contiene un messaggio ACK utilizzato come risposta da parte dell'adattatore quando tenta di pubblicare un messaggio.

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

4. 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 stai inviando i messaggi HL7v2.
   • PROJECT_ID è l'ID del progetto Google Cloud contenente l'argomento Pub/Sub.
   • PUBSUB_SUBSCRIPTION è il nome della prima sottoscrizione che hai creato associata al tuo primo argomento Pub/Sub. L'adattatore utilizza i messaggi di questa sottoscrizione e li conferma automaticamente.

   Dopo aver eseguito questo comando, l'adattatore inizia a essere eseguito su 127.0.0.1:2575. Pubblica nuovi messaggi al primo ricevitore esterno sulla porta 2525.

   Importante: se utilizzi Mac OS e questo comando non va a buon fine con un errore Connection refused, consulta Errore di connessione rifiutata durante l'esecuzione locale. Se questo comando ha esito negativo con una could not find default credentials errore, visualizza could not find default credentials errore durante l'esecuzione in locale.

Configurazione e avvio del secondo ricevitore e dell'adattatore

Per configurare e avviare il secondo ricevitore e l'adattatore, svolgi i seguenti passaggi:

1. Sulla macchina da cui hai eseguito il pull dell'immagine Docker predefinita, esegui il seguente comando per installare Netcat:

   sudo apt install netcat
   

2. Scarica hl7v2-mllp-ack-sample.txt, se non l'hai ancora fatto. Il file contiene un messaggio ACK utilizzato come risposta da parte dell'adattatore quando tenta di pubblicare un messaggio.

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

   Quando viene avviato il processo Netcat, viene visualizzato il seguente output:

   listening on [any] 2526 ...
   

4. Per avviare il secondo adattatore, in un nuovo terminale, esegui il seguente 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 stai inviando i messaggi HL7v2.
   • PROJECT_ID è l'ID del progetto Google Cloud contenente l'argomento Pub/Sub.
   • SECOND_PUBSUB_SUBSCRIPTION è il nome della seconda sottoscrizione che hai creato e associata al secondo argomento Pub/Sub. L'adattatore utilizza i messaggi di questa sottoscrizione li riconosce automaticamente.

   Dopo aver eseguito questo comando, l'adattatore inizia a funzionare sulla tua macchina locale sull'indirizzo IP 127.0.0.1:2576. Pubblica nuovi messaggi al secondo ricevitore esterno sulla porta 2526.

   Importante: se utilizzi Mac OS e questo comando non va a buon fine con un errore Connection refused, consulta Errore di connessione rifiutata durante l'esecuzione locale. Se questo comando non va a buon fine con un errore could not find default credentials., consulta Errore could not find default credentials durante l'esecuzione locale.

Pubblicazione di un messaggio per il primo destinatario

Per creare un messaggio da pubblicare solo per il primo destinatario esterno, completa i seguenti passaggi:

1. Scarica hl7v2-sample1.json.

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

   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

   L'esempio seguente mostra una richiesta POST che utilizza curl e un 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 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 le seguenti informazioni:

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

   L'esempio seguente mostra una richiesta POST mediante Windows PowerShell e un file JSON di esempio denominato hl7v2-sample1.json

   $cred = gcloud auth application-default print-access-token
   $headers = @{ Authorization = "Bearer $cred" }
   
   Invoke-WebRequest `
    -Method Post `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile hl7v2-sample1.json `
    -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages" | Select-Object -Expand Content

   Se la richiesta 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 su SEND_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é non viene inviata alcuna notifica al secondo argomento Pub/Sub.

   Nel terminale in cui hai eseguito il primo processo Netcat, viene visualizzata la 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 al momento della creazione del messaggio. È lo stesso del valore data nel file hl7v2-sample1.json.

Pubblicare un messaggio per il secondo destinatario

Per creare un messaggio che verrà pubblicato solo al secondo destinatario esterno:

1. Apri un nuovo terminale sulla tua macchina locale.

2. Per creare un messaggio da pubblicare solo nel secondo bucket esterno ricevitore, scarica hl7v2-sample2.json.

3. Nella directory in cui hai scaricato hl7v2-sample2.json, chiama il messages.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 utilizza curl e un 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 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 principale
   • Il 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, 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. È lo stesso del valore data nel file hl7v2-sample2.json.

Deployment dell'adattatore MLLP in Google Kubernetes Engine

Quando trasmetti messaggi HL7v2 tramite MLLP dal tuo centro sanitario, una possibile configurazione è inviare i messaggi a un adattatore di cui è stato eseguito il deployment in Google Cloud e che può 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. 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, il che rende 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 della tua 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 modificato dinamicamente tramite gli aggiornamenti della specifica del pod del deployment.

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 della configurazione del progetto, l'account di servizio predefinito potrebbe o meno avere le autorizzazioni per utilizzare altre API della piattaforma Cloud. GKE assegna inoltre alcuni ambiti di accesso limitato alle istanze Compute Engine.

Per risultati ottimali, non autenticarti ad altri servizi Google Cloud (come Pub/Sub) da i pod in esecuzione su GKE aggiornando le autorizzazioni dell'account di servizio predefinito o assegnando più ambiti di accesso alle istanze Compute Engine. Crea invece il tuo servizio Google Cloud.

Devi concedere le autorizzazioni Pub/Sub necessarie al cluster di contenitori, ma hai anche la possibilità di concedere le autorizzazioni per scrivere le metriche in Cloud Monitoring.

Per creare un nuovo account di servizio contenente solo gli ambiti richiesti dal cluster di contenitori, completa i seguenti passaggi:

Console

Crea un account di servizio:

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

   Vai a Crea account di servizio

2. Seleziona un progetto.

3. Inserisci un nome nel campo Nome account di servizio. La console 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.

4. Fai clic su Crea.

5. Fai clic sul campo Seleziona un ruolo.

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

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

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

   In Tutti i ruoli, fai clic su Monitoraggio > Scrittore di metriche di monitoraggio.

8. Fai clic su Continua.

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

   Non chiudere la finestra del browser. Userai la finestra nel prossimo .

gcloud

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

2. 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 regione us-west. Se hai impostato una zona predefinita utilizzando gcloud config set compute/zone, il valore di questo flag sostituisce il valore predefinito.
• CLIENT_EMAIL è l'identificatore dell'account di servizio che vuoi utilizzare. Utilizza 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 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, 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.

1. Apri un terminale separato.

2. 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 stai inviando i messaggi HL7v2.

Il deployment ha le seguenti proprietà:

• spec: replicas: è il numero di pod replicati gestiti dal deployment.
• spec: template: metadata: labels: è l'etichetta assegnata a 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 contenitore da eseguire in ogni pod e l'immagine del contenitore da eseguire.

Per ulteriori informazioni sulla specifica di deployment, consulta la documentazione di riferimento dell'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 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, 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 caso mllp-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 può ricevere il servizio da altri servizi nello stesso cluster. Viene utilizzata la porta MLLP predefinita di 2575.
• ports: targetPort: viene utilizzato per specificare la porta su ciascun pod in cui viene utilizzato il servizio in esecuzione.
• spec: selector: app: specifica i pod a cui è indirizzato il 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 saperne di più sul bilanciamento del carico interno, consulta la documentazione di GKE.

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

Eseguire il 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

Nota: kubectl apply non riesce se non hai un cluster attivo.

Ispezione del deployment

Dopo aver creato il deployment, puoi utilizzarlo per ispezionarlo.

Per informazioni dettagliate sul deployment, esegui il seguente 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 è andato a buon fine, l'ultima parte dell'output del comando precedente dovrebbe contenere le seguenti informazioni:

Events:
  Type    Reason     Age   From                                                  Message
  ----    ------     ----  ----                                                  -------
  Normal  Scheduled  1m    default-scheduler                                     Successfully assigned default/mllp-adapter-deployment-85b46f8-zxw68 to gke-mllp-adapter-default-pool-9c42852d-95sn
  Normal  Pulling    1m    kubelet, gke-mllp-adapter-default-pool-9c42852d-95sn  pulling image "gcr.io/cloud-healthcare-containers/mllp-adapter"
  Normal  Pulled     1m    kubelet, gke-mllp-adapter-default-pool-9c42852d-95sn  Successfully pulled image "gcr.io/cloud-healthcare-containers/mllp-adapter"
  Normal  Created    1m    kubelet, gke-mllp-adapter-default-pool-9c42852d-95sn  Created container
  Normal  Started    1m    kubelet, gke-mllp-adapter-default-pool-9c42852d-95sn  Started container

Esegui il deployment del servizio e crea il bilanciatore del carico interno

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

kubectl apply -f mllp_adapter_service.yaml

Il comando restituisce il seguente output:

service "mllp-adapter-service" created

Nota: kubectl apply non riesce se non hai un cluster attivo.

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

Nota: quando visualizzi l'output, IP e LoadBalancer Ingress non avranno lo stesso valore. Qui viene utilizzato lo stesso valore a scopo dimostrativo.

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

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, l'istanza e le istanze esistenti devono essere nella stessa regione e utilizzare 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. All'istanza VM 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:

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

   Vai a Crea account di servizio

2. Seleziona un progetto.

3. Inserisci un nome nel campo Nome account di servizio. La console 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.

4. Fai clic su Crea.

5. Fai clic sul campo Seleziona un ruolo.

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

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

7. Fai clic su Continua.

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

   Non chiudere la finestra del browser. Userai la finestra nel prossimo .

gcloud

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

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

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

   L'output include il criterio aggiornato:

   bindings:
       - members:
           - user:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
           role: roles/pubsub.publisher
       - members:
           - user:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
           roles/healthcare.hl7V2Consumer
       etag: ETAG
       version: 1

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

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai alla pagina Istanze VM

2. Fai clic su Crea istanza.

3. 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 seleziona us-central1 (Iowa) per la regione e us-central1-a per il Zona:

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

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

6. Fai clic su Seleziona.

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

8. Nella sezione Firewall, seleziona Consenti traffico HTTP.

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

gcloud

Per creare un'istanza Compute, esegui 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
• Il 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 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 questi passaggi:

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai alla pagina Istanze VM

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

gcloud

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

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

Ora hai una finestra del terminale per interagire con l'istanza Linux.

1. Nella finestra del terminale, installa Netcat:

   sudo apt install netcat
   

2. Scarica il file hl7v2-mllp-sample.txt e salvalo nell'istanza. Per informazioni sulla codifica e sul segmento di terminazione utilizzati nel file, consulta Separatori e codifica dei segmenti di messaggi HL7v2.

3. 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 di LoadBalancer Ingress visualizzato quando hai ispezionato il servizio.

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

   Dopo l'esecuzione del comando, il messaggio viene inviato tramite l'adattatore MLLP al 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.

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

5. Puoi anche elencare i messaggi nel tuo archivio HL7v2 per verificare 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 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 scoprirai come criptare in modo sicuro i messaggi HL7v2 trasmessi configurando una VPN tra un'istanza Compute Engine, che funge da istanza "on-premise", e l'adattatore.

Configurazione di una VPN

L'utilizzo di una VPN ti consente di estendere la rete privata su cui invii i messaggi HL7v2 su una rete pubblica, come internet. Se utilizzi una VPN, puoi inviare messaggi dal tuo centro assistenza tramite l'adattatore MLLP e a Google Cloud. I sistemi in questo flusso si comportano come se si trovassero su una singola rete privata.

Esistono due metodi per proteggere la connessione MLLP tramite VPN:

• Utilizzo di Cloud VPN
• Utilizzo della soluzione VPN end-to-end Strongswan su Docker

Configurazione di Cloud VPN

Cloud VPN connette in sicurezza la tua rete on-premise alla rete Virtual Private Cloud (VPC) di Google Cloud tramite una 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 trasmessi su internet o su una rete del centro assistenza.

In questo tutorial, ogni gateway VPN configurato 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 lato Google Cloud, mentre il gateway Cloud VPN in europe-west1 simula il gateway "on-premise".

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

Lato "On-premise"

• 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 dell'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 configurare Cloud VPN è creare due reti VPC. Una rete, chiamata on-prem-vpn-network, è configurata nell'ambiente "on-premise" ed è in esecuzione su un'istanza VM Compute Engine chiamata on-prem-instance. L'altra rete, chiamato cloud-vpn-network, è ciò che il 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:

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

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

2. Per creare la subnet subnet-us-central-10-0-1 per la rete cloud-vpn-network, esegui il comando seguente:

   gcloud compute networks subnets create subnet-us-central-10-0-1 \
      --project=PROJECT_ID \
      --region=us-central1 \
      --network=cloud-vpn-network \
      --range=10.0.1.0/24

3. Per creare la rete VPC on-prem-vpn-network, esegui questo comando :

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

4. Per creare la subnet subnet-europe-west-10-0-2 per la rete VPC on-prem-vpn-network, esegui il seguente 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:

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

   gcloud compute addresses create cloud-vpn-ip \
      --project=PROJECT_ID \
      --region=us-central1

2. Per prenotare un indirizzo IP esterno (statico) regionale per l'indirizzo on-prem-vpn-ip , esegui il seguente comando:

   gcloud compute addresses create on-prem-vpn-ip \
      --project=PROJECT_ID \
      --region=europe-west1

3. Prendi nota degli indirizzi IP esterni in modo da poterli utilizzare per configurare i gateway VPN nella sezione successiva. Per recuperare gli indirizzi IP esterni, esegui il seguente comando:

   Indirizzo IP Cloud VPN:

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

   Indirizzo IP della 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:

1. Crea una chiave precondivisa (segreto condiviso) di crittografia efficace seguendo le istruzioni riportate in Generazione di una chiave precondivisa efficace. In questa sezione viene fatto riferimento a questa chiave come SHARED_SECRET.

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

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

4. Per creare un tunnel nel gateway Cloud VPN, esegui il seguente 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

5. Per creare una route statica per 10.0.2.0/24, esegui il seguente 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 VPN, il tunnel e il percorso per la VPN "on-premise":

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

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

2. Per creare tre regole di forwarding, esegui 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

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

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

1. Per creare le regole firewall per la subnet Cloud VPN, esegui il 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

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

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

1. Vai alla pagina VPN nella console Google Cloud.

   Vai alla pagina VPN

2. Fai clic sulla scheda Tunnel VPN di Google.

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

   Per ulteriori informazioni sul logging relative ai tunnel VPN, consulta Controllare i log della VPN della pagina Risoluzione dei problemi. Per Ad esempio, puoi visualizzare le metriche sui pacchetti eliminati, sullo 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 in GKE e Cloud VPN

Se all'inizio di questo tutorial hai testato l'adattatore MLLP localmente e inviato messaggi HL7v2 tramite una connessione non VPN all'adattatore MLLP, ora invierai messaggi da una VM 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.

Ricreare il deployment

Innanzitutto, ricrea il deployment su GKE in modo che il cluster utilizza le impostazioni che hai configurato Configurazione di Cloud VPN:

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

   gcloud container clusters delete mllp-adapter --zone=COMPUTE_ZONE

2. Segui i passaggi in Deployment dell'adattatore MLLP in Kubernetes Engine, ma quando crei il cluster in GKE, aggiungi la rete cloud-vpn-network e subnet-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 è dipiegato il 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 in us-central1: us-central1-c, us-central1-a, us-central1-f, us-central1-b.

     Nota: il cluster GKE e il "lato Google Cloud" la rete deve trovarsi nella stessa regione, altrimenti il routing non funzionerà.

   • CLIENT_EMAIL è l'identificatore dell'account di servizio che vuoi utilizzare. 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 che seguono mostrano come creare un'istanza di macchina virtuale Linux in Compute Engine utilizzando la console Google Cloud. A differenza della VM Compute Engine che hai creato, questa VM utilizza le impostazioni di rete "lato on-premise" per comunicare con il cluster GKE tramite una VPN.

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai alla pagina Istanze VM

2. Fai clic su Crea istanza.

3. Scegli una regione e una zona per l'istanza che corrisponda alla "'on-premise'" " impostazioni di rete: europe-west1 (Belgium) per la Regione e europe-west1-b per la zona.

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

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

6. Fai clic su Seleziona.

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

8. Nella sezione Firewall, seleziona Consenti traffico HTTP.

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

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

    1. Nel campo Rete, seleziona on-prem-vpn-network.
    2. Nel campo Subnet, seleziona subnet-europe-west-10-0-2 (10.0.2.0/24).

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

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

gcloud

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

• Il valore ZONE corrispondente 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-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:

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai alla pagina Istanze VM

2. 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 l'istanza Linux.

1. Nella finestra del terminale, installa Netcat:

   sudo apt install netcat
   

2. Scarica hl7v2-mllp-sample.txt e salvarlo nell'istanza.

3. Per iniziare a inviare messaggi HL7v2 tramite l'adattatore MLLP al tuo archivio HL7v2, esegui il seguente comando nella directory in cui hai scaricato il file. Utilizza il valore di LoadBalancer Ingress visualizzato quando hai ispezionato 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 per nel tuo archivio HL7v2. Se il messaggio è stato importato correttamente nell'archivio HL7v2, il comando restituisce il seguente output:

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

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

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

   gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION

   Il comando restituisce il seguente output sul messaggio HL7v2 importato:

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

5. Puoi anche elencare i messaggi nel tuo archivio HL7v2 per verificare 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 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, avrai eseguito il deployment dell'adattatore MLLP in GKE e, tramite una VPN, avrai inviato in modo sicuro un messaggio HL7v2 da un'istanza "on-premise" tramite l'adattatore 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 eliminare le risorse che hai creato su Google Cloud.

Elimina il progetto

Per eliminare il progetto creato in questo tutorial:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini elimini anche tutto il lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Risoluzione dei problemi

Errori dell'adattatore

Dopo il deployment dell'adattatore MLLP in GKE, l'adattatore riscontra 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. Anziché utilizzare il --network=host, utilizza -p 2575:2575. Inoltre, invece di impostare --receiver_ip=127.0.0.0, imposta --receiver_ip=0.0.0.0. Il comando dovrebbe avere questo aspetto:

  Nota: quando fornisci un valore per --pubsub_subscription, inserisci solo il nome dell'abbonamento, non l'URI completo. Ad esempio, se l'URI per il tuo abbonamento è projects/my-projects/subscriptions/my-subscription, fornisci solo my-subscription.

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

could not find default credentials errore durante l'esecuzione in locale

Quando testi l'adattatore MLLP localmente, si verifica l'errore healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials..

Questo errore si verifica quando l'adattatore non riesce a trovare le credenziali ADC locali. Assicurati di aver configurato le credenziali predefinite dell'applicazione nel tuo ambiente locale.

Errori di autenticazione

Se riscontri errori di autenticazione durante il test dell'adattatore MLLP localmente che non sono coperti nel resto di questa sezione, esegui di nuovo il comando docker run e aggiungi il flag -v ~/.config:/root/.config alla fine del comando, come segue:

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