Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Transmite mensajes HL7v2 a través de conexiones TCP/IP

En este instructivo, se proporcionan instrucciones para transmitir mensajes HL7v2 a través de conexiones TCP/IP mediante el protocolo de capa inferior mínima (MLLP). Para solicitar que la imagen de MLLP esté firmada por un certificador, sigue los pasos en Transmite mensajes HL7v2 a través de conexiones TCP/IP con una imagen de MLLP firmada.

En este instructivo, se proporcionan instrucciones para ejecutar el adaptador de código abierto de MLLP alojado en GitHub en los entornos siguientes:

Objetivos

Después de completar el instructivo, sabrás cómo realizar las siguientes actividades:

Costos

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

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

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto. Los usuarios nuevos de Cloud Platform podrían cumplir con los requisitos para obtener una prueba gratuita.

Antes de comenzar

Antes de comenzar este instructivo, familiarízate con la documentación conceptual sobre el protocolo de capa inferior mínima (MLLP) mediante la revisión de MLLP y el adaptador de MLLP de Google Cloud . La documentación conceptual proporciona una descripción general de MLLP, cómo los sistemas de cuidado pueden enviar y recibir mensajes hacia y desde la API de Cloud Healthcare a través de una conexión MLLP y los conceptos básicos de seguridad de MLLP.

Antes de configurar el adaptador de MLLP, debes elegir o crear un proyecto de Google Cloud y habilitar las API necesarias mediante los siguientes pasos:

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir a la página del selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Descubre cómo confirmar que tienes habilitada la facturación en un proyecto.

  4. Habilita las API de Cloud Healthcare API, Google Kubernetes Engine, Container Registry, and Pub/Sub.

    Habilita las API

  5. Espera a que la API de Kubernetes Engine y los servicios relacionados se habiliten. Esto puede tomar varios minutos.

Elige un shell

Para completar este instructivo, puedes usar Cloud Shell o tu shell local.

Cloud Shell es un entorno de shell que se usa para administrar recursos alojados en Google Cloud. Cloud Shell viene preinstalado con la herramienta de gcloud y la herramienta kubectl. La herramienta de gcloud proporciona la interfaz de línea de comandos principal para GCP. kubectl proporciona la interfaz de línea de comandos para ejecutar comandos con clústeres de GKE.

Si prefieres usar tu shell local, debes instalar el SDK de Cloud, que incluye la herramienta gcloud y la herramienta kubectl.

Para abrir Cloud Shell o configurar tu shell local, completa los siguientes pasos:

Cloud Shell

Para iniciar Cloud Shell, sigue estos pasos:

  1. Ve a Google Cloud Console

    Google Cloud Console

  2. En la esquina superior derecha de la consola, haz clic en el botón Activar Google Cloud Shell:

Se abrirá una sesión de Cloud Shell dentro de un marco en la parte inferior de la consola. Usa este shell para ejecutar los comandos gcloud y kubectl.

Shell local

Para instalar las herramientas gcloud y kubectl, completa los siguientes pasos:

  1. Instala e inicializa el SDK de Cloud.
  2. Si solo pruebas el adaptador de manera local, no necesitas completar más pasos y puedes continuar Crea un conjunto de datos. Si implementas el adaptador en GKE, ejecuta el siguiente comando para instalar la herramienta de línea de comandos de kubectl:

    gcloud components install kubectl

Crea un conjunto de datos

Si aún no creaste un conjunto de datos de la API de Cloud Healthcare, sigue estos pasos para crear uno:

Console

  1. En Cloud Console, ve a la página Conjuntos de datos.

    Ir a la página Conjuntos de datos

  2. Haz clic en Create dataset.
  3. Elige un identificador de conjuntos de datos que sea único en el proyecto y la región. Si el identificador no es único, la creación del conjunto de datos fallará.
  4. Elige la región en la que reside el conjunto de datos de forma permanente y haz clic en Crear.

El conjunto de datos nuevo aparecerá en la lista.

gcloud

Para crear un conjunto de datos, ejecuta el comando gcloud healthcare datasets create:

gcloud healthcare datasets create DATASET_ID \
    --location=LOCATION

Si la solicitud es exitosa, el comando mostrará el siguiente resultado:

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

Crea una suscripción y un tema de Pub/Sub

Para recibir notificaciones cuando se crean o transfieren mensajes, debes configurar un tema de Pub/Sub con tu almacén de HL7v2. Para obtener más información, consulta Configurar notificaciones de Pub/Sub.

Para crear un tema, completa los siguientes pasos:

Console

  1. Ve a la página Temas de Pub/Sub en Cloud Console.

    Ir a la página de Cloud Pub/Sub

  2. Haz clic en Crear tema.

  3. Ingresa un nombre de tema con el URI:

    projects/PROJECT_ID/topics/TOPIC_NAME

    En el ejemplo anterior, PROJECT_ID es el ID del proyecto de Google Cloud.

  4. Haga clic en Crear.

gcloud

Para crear un tema, ejecuta el comando gcloud pubsub topics create:

gcloud pubsub topics create projects/PROJECT_ID/topics/TOPIC_NAME

Si la solicitud es exitosa, el comando mostrará el siguiente resultado:

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

Para crear una suscripción, realiza los pasos que se indican a continuación.

Console

  1. Ve a la página Temas de Pub/Sub en Cloud Console.

    Ir a la página de Cloud Pub/Sub

  2. Haz clic en el tema de tu proyecto.

  3. Haz clic en Crear suscripción.

  4. Ingresa un nombre de suscripción.

    projects/PROJECT_ID/subscriptions/SUBSCRIPTION_NAME

  5. Deja el Tipo de entrega configurado en Extraer y, luego, haz clic en Crear.

gcloud

Para crear una suscripción, ejecuta el comando gcloud pubsub subscriptions create.

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

Si la solicitud es exitosa, el comando mostrará el siguiente resultado:

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

Crea una tienda HL7v2 configurada con un tema de Pub/Sub

Crea una tienda HL7v2 y configurarla con un tema de Pub/Sub Para crear una tienda HL7v2, ya debes haber creado un conjunto de datos. A los fines de este instructivo, usa el mismo proyecto para tu almacén de HL7v2 y el tema de Pub/Sub.

Para crear una tienda HL7v2 configurada con un tema de Pub/Sub, completa los siguientes pasos:

curl

curl -X POST \
    --data "{
      'notificationConfigs': [
        {
          'pubsubTopic': 'projects/PROJECT_ID/topics/PUBSUB_TOPIC',
          'filter': ''
        }
      ]
    }" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores?hl7V2StoreId=HL7V2_STORE_ID"

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

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

PowerShell

$cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Post `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -Body "{
      'notificationConfigs': [
        {
          'pubsubTopic': 'projects/PROJECT_ID/topics/PUBSUB_TOPIC',
          'filter': ''
        }
      ]
  }" `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores?hl7V2StoreId=HL7V2_STORE_ID" | Select-Object -Expand Content

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

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

Configura permisos de Pub/Sub

Para enviar notificaciones a Pub/Sub cuando se crea o transfiere un mensaje HL7v2, debes configurar los permisos de Pub/Sub en la API de Cloud Healthcare. Este paso debe realizarse una vez por proyecto.

Para agregar la función de pubsub.publisher requerida a la cuenta de servicio de tu proyecto, completa los siguientes pasos:

Console

  1. En la página IAM en Cloud Console, verifica que la función Agente de servicio de Healthcare aparezca en la columna función para la cuenta de servicio del proyecto correspondiente. El nombre de la cuenta es service-PROJECT_NUMBER@gcp-sa-healthcare.iam.gserviceaccount.com. Para obtener información sobre cómo encontrar el PROJECT_NUMBER, consulte Identifica proyectos.

  2. En la columna Herencia que coincide con la función, haz clic en el ícono de lápiz. Se abrirá el panel Editar permisos.

  3. Haz clic en Agregar otra función y, luego, busca la función de Publicador de Pub/Sub.

  4. Selecciona la función y haz clic en Guardar. La función pubsub.publisher se agrega a la cuenta de servicio.

gcloud

Para agregar los permisos de la cuenta de servicio, ejecuta el comando gcloud projects add-iam-policy-binding. Para obtener más información sobre cómo buscar PROJECT_ID y PROJECT_NUMBER, consulta Identifica proyectos.

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

Extrae la imagen de Docker compilada previamente

El adaptador de MLLP es una aplicación en contenedores almacenada en etapa intermedia en una imagen de Docker compilada previamente en Container Registry.

Para extraer la versión más reciente de la imagen, ejecuta el siguiente comando:

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

Prueba el adaptador de MLLP de forma local

Cuando pruebas el adaptador de forma local, puedes configurarlo para que se ejecute como receiver, un publisher o ambos. Las configuraciones del receptor y del publicador tienen las siguientes diferencias clave:

  • Cuando el adaptador se ejecuta como un receptor, recibe mensajes HL7v2 de una fuente externa y llama a messages.ingest para transferir los mensajes a un almacén HL7v2, lo que crea una notificación de Pub/Sub. La notificación se envía a las aplicaciones suscritas al tema de Pub/Sub del almacén HL7v2.
  • Cuando el adaptador se ejecuta como publicador, escucha los mensajes HL7v2 que se crearon o transfirieron en un almacén HL7v2 mediantemessages.create omessages.ingest las rutas "a GCP". Después de crear un mensaje, se envía una notificación de Pub/Sub al adaptador y el adaptador publica los mensajes en un receptor externo.

En las siguientes secciones, se muestra cómo ejecutar el adaptador de modo que actúe como un receptor o un editor.

Después de verificar que puedes ejecutar el adaptador de MLLP en tu máquina local, puedes continuar con la siguiente sección en Implementa el adaptador de MLLP en Google Kubernetes Engine.

Prueba el adaptador de MLLP de manera local como receptor

Cuando el adaptador recibe un mensaje HL7v2 de una fuente externa, como un centro de atención médica, el adaptador llama a messages.ingest y transfiere el mensaje HL7v2 a la tienda HL7v2 configurada. Puedes observar esto en el código fuente del adaptador.

Para probar el adaptador de forma local como receptor, completa los siguientes pasos:

  1. En la máquina en la que extrajiste la imagen de Docker compilada con anterioridad, ejecuta el siguiente 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
    

    Donde:

    • PROJECT_ID es el ID del proyecto de Google Cloud que contiene tu almacén HL7v2.
    • LOCATION es la región en la que se encuentra tu almacén HL7v2.
    • DATASET_ID es el ID del conjunto de datos superior de tu almacén HL7v2.
    • HL7V2_STORE_ID es el ID de la tienda HL7v2 al que envías mensajes HL7v2.

    Después de ejecutar el comando anterior, el adaptador imprime un mensaje similar al siguiente y comienza a ejecutarse en tu máquina local en la dirección IP 127.0.0.1 en el puerto 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.
    

    Si encuentras errores, sigue estos pasos para solucionar problemas:

  2. Para continuar con las pruebas mientras el adaptador se ejecuta como un proceso en primer plano, abre una terminal diferente en tu máquina local.

  3. En la terminal nueva, para instalar Netcat, ejecuta el siguiente comando:

    sudo apt install netcat
    
  4. Descarga el archivo hl7v2-mllp-sample.txt y guárdalo en tu máquina local.

  5. Para enviar el mensaje HL7v2 al adaptador, ejecuta el siguiente comando en el directorio donde descargaste el archivo. El adaptador de MLLP está escuchando en tu host local en el puerto 2575. El comando envía el mensaje a través del adaptador de MLLP en tu almacén HL7v2.

    Linux

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

    Si el mensaje se transfirió correctamente al almacén de HL7v2, el comando mostrará el siguiente resultado:

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

    Este resultado indica que la tienda HL7v2 respondió con un tipo de respuesta AA (Application Accept), lo que significa que el mensaje se valida y se transfiere correctamente.

  6. Para verificar que el mensaje se haya enviado correctamente, abre la terminal en la que ejecutaste el adaptador. El resultado debería verse como el ejemplo siguiente:

     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. El mensaje se almacena en tu almacén de HL7v2, por lo que puedes llamar a messages.list para ver el mensaje:

    curl

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

    Si la solicitud es exitosa, el servidor muestra el ID del mensaje en una ruta de recursos:

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

    PowerShell

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

    Si la solicitud es exitosa, el servidor muestra el ID del mensaje en una ruta de recursos:

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

Prueba el adaptador de MLLP de manera local como publicador

Cuando pruebas el adaptador como publicador, debes crear mensajes mediante una llamada a messages.create o messages.ingest y suministra un archivo de mensaje como datos binarios.

El adaptador confirma automáticamente los mensajes de Pub/Sub enviados a través de messages.create y messages.ingest.

El adaptador te notifica cuando recupera y envía correctamente mensajes de Pub/Sub. El adaptador es un suscriptor de Pub/Sub, por lo que reconoce estos mensajes de forma automática. Como resultado, se quitan de la cola de mensajes de la suscripción a Pub/Sub que configuraste con el adaptador.

Para extraer la suscripción a Pub/Sub y verificar por separado que los mensajes se publicaron, debes crear una segunda suscripción a Pub/Sub asignada al tema que creaste anteriormente. El adaptador no reconoce automáticamente los mensajes enviados a la segunda suscripción y quedan, por lo que puedes extraerlos.

Para crear una segunda suscripción de Pub/Sub asignada al tema que creaste anteriormente, completa los siguientes pasos:

Console

  1. Ve a la página Temas de Pub/Sub en Cloud Console.

    Ir a la página de Cloud Pub/Sub

  2. Haz clic en el tema de tu proyecto. Este es el tema que usaste para crear la suscripción inicial.

  3. Haz clic en Crear suscripción.

  4. Ingresa un nombre de suscripción.

    projects/PROJECT_ID/subscriptions/SECOND_SUBSCRIPTION_NAME

    Configura el Tipo de entrega como Extracción.

  5. Haz clic en Crear.

gcloud

Para crear una segunda suscripción a Pub/Sub asignada al tema que creaste anteriormente, ejecuta el comando gcloud pubsub subscriptions create:

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

Si la solicitud es exitosa, el comando mostrará el siguiente resultado:

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

Para probar el adaptador de forma local como publicador, completa los siguientes pasos en la máquina en la que extrajiste la imagen precompilada de Docker:

  1. Instala Netcat:

    sudo apt install netcat
    
  2. Descarga el archivo hl7v2-mllp-ack-sample.txt y guárdalo en tu máquina local. El archivo contiene un mensaje ACK que el adaptador requiere como respuesta cuando intenta publicar un mensaje.

  3. Para permitir que Netcat escuche las conexiones entrantes en el puerto 2525, en el directorio donde descargaste el archivo, ejecuta el siguiente comando.

    Linux

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

    Después de iniciar Netcat, se muestra un mensaje de resultado similar al del siguiente ejemplo:

    listening on [any] 2525 ...
    
  4. Netcat se ejecuta como un proceso en primer plano, por lo que para continuar con las pruebas, abre otra terminal en tu máquina local.

  5. Para iniciar el adaptador, ejecuta el siguiente comando en la terminal nueva:

    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
    

    Donde:

    • PROJECT_ID es el ID del proyecto de Google Cloud que contiene tu almacén HL7v2.
    • LOCATION es la región en la que se encuentra tu almacén HL7v2.
    • DATASET_ID es el ID del conjunto de datos superior de tu almacén HL7v2.
    • HL7V2_STORE_ID es el ID de la tienda HL7v2 al que envías mensajes HL7v2.
    • PROJECT_ID es el ID del proyecto de Google Cloud que contiene el tema de Pub/Sub.
    • PUBSUB_SUBSCRIPTION es el nombre de la primera suscripción que creaste que está asociada con tu tema de Pub/Sub. El adaptador consume mensajes de esta suscripción y los confirma de forma automática, por lo que para ver los mensajes publicados en el tema, debes extraer los mensajes de la segunda suscripción que creaste anteriormente.

    Después de ejecutar el comando anterior, el adaptador comienza a ejecutarse en tu máquina local en la dirección IP 127.0.0.1 en el puerto 2575.

    Si encuentras errores, sigue estos pasos para solucionar problemas:

    El adaptador se ejecuta como un proceso en primer plano, por lo tanto, para continuar con la prueba, abre una terminal diferente en tu máquina local.

  6. Descarga el archivo hl7v2-sample.json y guárdalo en tu máquina local. En el directorio en el que descargaste el archivo, llama al método messages.create para crear el mensaje en un almacén de HL7v2:

    curl

    Para crear un mensaje HL7v2, realiza una solicitud POST y especifica la siguiente información:

    • El nombre del conjunto de datos superior
    • El nombre del almacén de HL7v2
    • Un mensaje
    • Un token de acceso

    En el siguiente ejemplo, se muestra una solicitud POST con curl y un archivo JSON de ejemplo llamado hl7v2-sample.json.

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

    Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

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

    Para crear un mensaje HL7v2, realiza una solicitud POST y especifica la siguiente información:

    • El nombre del conjunto de datos superior
    • El nombre del almacén de HL7v2
    • Un mensaje
    • Un token de acceso

    En el siguiente ejemplo, se muestra una solicitud POST mediante Windows PowerShell y un archivo JSON de muestra llamado hl7v2-sample.json.

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

    Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

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

    Después de crear el mensaje, el adaptador de MLLP muestra la siguiente respuesta:

    I0214 00:00:00.000000       1 healthapiclient.go:266] Started to fetch message.
    I0214 00:00:00.000000       1 healthapiclient.go:283] Message was successfully fetched.
    
  7. En la terminal donde ejecuta Netcat, se muestra un resultado similar al siguiente ejemplo. Este resultado indica que se publicó el mensaje:

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

    Esto corresponde al valor del campo data de la respuesta que recibiste cuando creaste el mensaje. Es el mismo que el valor data en el archivo hl7v2-sample.json.

  8. Para ver el mensaje que el adaptador publicó en el tema de Pub/Sub, ejecuta el comando gcloud pubsub subscriptions pull en la segunda suscripción a Pub/Sub que creaste:

    gcloud pubsub subscriptions pull --auto-ack SECOND_SUBSCRIPTION
    

    El comando muestra el siguiente resultado sobre el mensaje HL7v2 creado. Observa el valor publish=true en la columna ATTRIBUTES, que indica que el mensaje se publicó en 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  |
    └-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘
    

Publica mensajes en diferentes receptores externos

Puedes configurar el almacén de HL7v2 con varios temas de Pub/Sub y usar filtros para enviar notificaciones a diferentes temas de Pub/Sub. Luego, puedes ejecutar un adaptador de MLLP para cada tema de Pub/Sub a fin de publicar los mensajes en un receptor externo diferente.

Si deseas configurar la tienda HL7v2 con varios temas de Pub/Sub y un filtro para cada tema, completa los siguientes pasos:

  1. Crear dos temas de Pub/Sub y una suscripción para cada tema Para obtener más información, consulta Crear un tema y una suscripción de Pub/Sub.

  2. Ejecuta el siguiente 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"
    

    Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

    {
      "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID",
      "notificationConfigs": [
        {
          "pubsubTopic": "projects/PROJECT_ID/topics/PUBSUB_TOPIC",
          "filter": "sendFacility=\"SEND_FACILITY_1\""
        },
        {
          "pubsubTopic": "projects/PROJECT_ID/topics/SECOND_PUBSUB_TOPIC",
          "filter": "sendFacility=\"SEND_FACILITY_2\""
        }
      ]
    }
    

    PowerShell

    $cred = gcloud auth application-default print-access-token
    $headers = @{ Authorization = "Bearer $cred" }
    
    Invoke-WebRequest `
      -Method Patch `
      -Headers $headers `
      -ContentType: "application/json; charset=utf-8" `
      -Body "{
          'notificationConfigs': [
            {
              'pubsubTopic' : 'projects/PROJECT_ID/topics/PUBSUB_TOPIC',
              'filter': 'sendFacility=\"SEND_FACILITY_1\"'
            },
            {
              'pubsubTopic' : 'projects/PROJECT_ID/topics/SECOND_PUBSUB_TOPIC',
              'filter' : 'sendFacility=\"SEND_FACILITY_2\"'
            }
          ]
      }" `
      -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores?hl7V2StoreId=HL7V2_STORE_ID?updateMask=notificationConfigs" | Select-Object -Expand Content
    

    Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

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

Prueba el enrutamiento de mensajes

Para probar el enrutamiento de los mensajes, completa los pasos en las siguientes secciones.

Configura y, luego, inicia el primer receptor y adaptador

Para configurar y, luego, iniciar el primer receptor y adaptador, completa los siguientes pasos:

  1. En la máquina donde extrajiste la imagen precompilada de Docker, ejecuta el siguiente comando para instalar Netcat:

    sudo apt install netcat
    
  2. Descarga hl7v2-mllp-ack-sample.txt, si aún no lo hiciste. El archivo contiene un mensaje ACK que el adaptador usa como respuesta cuando intenta publicar un mensaje.

  3. Para configurar el puerto 2525 del primer receptor, ejecuta el siguiente comando:

    Linux

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

    Cuando se inicia el proceso de Netcat, se muestra el siguiente resultado:

    listening on [any] 2525 ...
    
  4. Para iniciar el primer adaptador, en una terminal nueva, ejecuta el siguiente 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
    

    Donde:

    • PROJECT_ID es el ID del proyecto de Google Cloud que contiene tu almacén HL7v2.
    • LOCATION es la región en la que se encuentra tu almacén HL7v2.
    • DATASET_ID es el ID del conjunto de datos superior de tu almacén HL7v2.
    • HL7V2_STORE_ID es el ID de la tienda HL7v2 al que envías mensajes HL7v2.
    • PROJECT_ID es el ID del proyecto de Google Cloud que contiene el tema de Pub/Sub.
    • PUBSUB_SUBSCRIPTION es el nombre de la primera suscripción que creaste y está asociada a tu primer tema de Pub/Sub. El adaptador consume mensajes de esta suscripción y los confirma de forma automática.

    Después de ejecutar este comando, el adaptador comienza a ejecutarse en tu máquina local en 127.0.0.1:2575. Publica mensajes nuevos para el primer receptor externo en el puerto 2525.

Configura y, luego, inicia el segundo receptor y adaptador

Para configurar y, luego, iniciar el segundo receptor y adaptador, completa los siguientes pasos:

  1. En la máquina donde extrajiste la imagen precompilada de Docker, ejecuta el siguiente comando para instalar Netcat:

    sudo apt install netcat
    
  2. Descarga hl7v2-mllp-ack-sample.txt, si aún no lo hiciste. El archivo contiene un mensaje ACK que el adaptador usa como respuesta cuando intenta publicar un mensaje.

  3. Para configurar el puerto 2526 para el segundo receptor, ejecuta el siguiente comando.

    Linux

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

    Cuando se inicia el proceso de Netcat, se muestra el siguiente resultado:

    listening on [any] 2526 ...
    
  4. Para iniciar el segundo adaptador, ejecuta el siguiente comando en una terminal nueva:

    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
    

    Donde:

    • PROJECT_ID es el ID del proyecto de Google Cloud que contiene tu almacén HL7v2.
    • LOCATION es la región en la que se encuentra tu almacén HL7v2.
    • DATASET_ID es el ID del conjunto de datos superior de tu almacén HL7v2.
    • HL7V2_STORE_ID es el ID de la tienda HL7v2 al que envías mensajes HL7v2.
    • PROJECT_ID es el ID del proyecto de Google Cloud que contiene el tema de Pub/Sub.
    • SECOND_PUBSUB_SUBSCRIPTION es el nombre de la segunda suscripción que creaste y está asociada a tu segundo tema de Pub/Sub. El adaptador consume mensajes de esta suscripción y los confirma de forma automática.

    Después de ejecutar este comando, el adaptador comienza a ejecutarse en tu máquina local en la dirección IP del puerto 127.0.0.1:2576. Publica mensajes nuevos en el segundo receptor externo en el puerto 2526.

Publica un mensaje en el primer receptor

Para crear un mensaje que solo se publicará en el primer receptor externo, completa los siguientes pasos:

  1. Descargar hl7v2-sample1.json.

  2. En el directorio donde descargaste hl7v2-sample1.json, llama al método messages.create para crear el mensaje en una tienda HL7v2:

    curl

    Para crear un mensaje de HL7v2, realiza una solicitud POST y especifica la siguiente información:

    • El nombre del conjunto de datos superior
    • El nombre del almacén de HL7v2
    • Un mensaje
    • Un token de acceso

    En el siguiente ejemplo, se muestra una solicitud POST mediante curl y un archivo JSON de muestra, hl7v2-sample1.json.

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

    Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

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

    Para crear un mensaje de HL7v2, realiza una solicitud POST y especifica la siguiente información:

    • El nombre del conjunto de datos superior
    • El nombre del almacén de HL7v2
    • Un mensaje
    • Un token de acceso

    En el siguiente ejemplo, se muestra una solicitud POST mediante Windows PowerShell y un archivo JSON de muestra llamado hl7v2-sample1.json.

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

    Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

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

    En esta respuesta, sendFacility se configura como SEND_FACILITY_1, por lo que la notificación de Pub/Sub solo se envía al primer tema de Pub/Sub. Después de crear el mensaje, el primer adaptador de MLLP muestra la siguiente respuesta:

    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.
    

    El segundo adaptador de MLLP no muestra ninguna respuesta porque no se envía ninguna notificación al segundo tema de Pub/Sub.

    En la terminal en la que ejecutaste el primer proceso de Netcat, se muestra el siguiente resultado. Este resultado indica que se publicó el mensaje.

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

    Este resultado corresponde al valor en el campo data de la respuesta que recibiste cuando creaste el mensaje. Es el mismo que el valor data en el archivo hl7v2-sample1.json.

Publica un mensaje en el segundo receptor

Para crear un mensaje que solo se publicará en el segundo receptor externo, sigue estos pasos:

  1. Abre una terminal nueva en la máquina local.

  2. Para crear un mensaje que solo se publicará en el segundo receptor externo, descarga hl7v2-sample2.json.

  3. En el directorio donde descargaste hl7v2-sample2.json, llama al método messages.create para crear el mensaje en una tienda HL7v2:

    curl

    Para crear un mensaje de HL7v2, realiza una solicitud POST y especifica la siguiente información:

    • El nombre del conjunto de datos superior
    • El nombre del almacén de HL7v2
    • Un mensaje
    • Un token de acceso

    En el siguiente ejemplo, se muestra una solicitud POST mediante curl y un archivo JSON de muestra, hl7v2-sample2.json.

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

    Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

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

    Para crear un mensaje HL7v2, realiza una solicitud POST y especifica la siguiente información:

    • El nombre del conjunto de datos superior
    • El nombre del almacén de HL7v2
    • Un mensaje
    • Un token de acceso

    En el siguiente ejemplo, se muestra una solicitud POST mediante Windows PowerShell y un archivo JSON de muestra, hl7v2-sample2.json.

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

    Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

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

    Ten en cuenta que sendInstallation es SEND_FACILITY_2, por lo que la notificación de Pub/Sub solo se envía al segundo tema de Pub/Sub. Después de crear el mensaje, el primer adaptador de MLLP no muestra ninguna respuesta, mientras que el segundo adaptador de MLLP muestra la siguiente respuesta:

    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.
    

    En la terminal donde ejecutaste el segundo proceso de Netcat, se muestra el siguiente resultado. Este resultado indica que se publicó el mensaje.

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

    Este resultado corresponde al valor en el campo data de la respuesta que recibiste cuando creaste el mensaje. Es el mismo que el valor data en el archivo hl7v2-sample2.json.

Implementa el adaptador de MLLP en Google Kubernetes Engine

Cuando transmites mensajes HL7v2 a través de MLLP desde tu centro de atención, una configuración posible es enviar los mensajes a un adaptador que se implementa en Google Cloud y puede reenviarlos a la API de Cloud Healthcare.

El adaptador de MLLP se ejecuta como una aplicación sin estado en un clúster de GKE. Un clúster de GKE es un grupo administrado de instancias de VM para ejecutar aplicaciones en contenedores. Las aplicaciones sin estado son aplicaciones que no almacenan los datos o el estado de la aplicación en el clúster o en almacenamiento continuo. En cambio, los datos y el estado de la aplicación se quedan con el cliente. Esto hace que las aplicaciones sin estado sean más escalables.

GKE usa el controlador de Deployment para implementar aplicaciones sin estado como pods uniformes y no únicos. Los Deployments administran el estado deseado de tu aplicación: cuántos Pods deben ejecutar tu aplicación, qué versión de imagen del contenedor se debe ejecutar, cómo se deben etiquetar los Pods, etcétera. El estado deseado puede modificarse de forma dinámica mediante actualizaciones en la especificación del Pod de la implementación.

Al mismo tiempo que implementas el adaptador, creas un Servicio controlador que te permite conectar el adaptador a la API de Cloud Healthcare mediante el balanceo de cargas interno.

Si eres nuevo en GKE, debes completar la guía de inicio rápido de GKE para obtener información sobre cómo funciona el producto.

Agrega permisos de la API de Pub/Sub a la cuenta de servicio de GKE

Como se indica en la documentación de GKE Autentica Cloud Platform con cuentas de servicio, cada nodo en un clúster de contenedores es una instancia de Compute Engine. Por lo tanto, cuando el adaptador de MLLP se ejecuta en un clúster de contenedor, hereda automáticamente los permisos de las instancias de Compute Engine en las que se implementa.

Google Cloud crea automáticamente una cuenta de servicio llamada “Cuenta de servicio predeterminada de Compute Engine” y GKE asocia esta cuenta de servicio con los nodos que crea GKE. Según cómo esté configurado tu proyecto, es posible que la cuenta de servicio predeterminada tenga o no permisos para usar otras API de Cloud Platform. GKE también asigna algunos permisos de acceso limitado a las instancias de Compute Engine.

Para obtener mejores resultados, no te autentiques en otros servicios de Google Cloud (como Pub/Sub) desde los pods que se ejecutan en GKE. Para ello, actualiza los permisos de la cuenta de servicio predeterminada o asigna más niveles de acceso a Compute Engine{ 101}instancias. En su lugar, crea tus propias cuentas de servicio.

Debes otorgar los permisos de Pub/Sub necesarios al clúster del contenedor, pero también tienes la opción de otorgar permisos para escribir métricas en Cloud Monitoring.

Para crear una cuenta de servicio nueva que contenga solo los permisos que requiere el clúster del contenedor, completa los siguientes pasos:

Console

  1. En Cloud Console, ve a la página Crea una clave de cuenta de servicio.

    Ir a la página Crear clave de la cuenta de servicio

  2. En la lista Cuenta de servicio, selecciona Cuenta de servicio nueva.

  3. Ingresa un nombre en el campo Nombre de cuenta de servicio.

  4. En la lista Función, selecciona las siguientes funciones:

    • Pub/Sub > Suscriptor de Pub/Sub
    • Cloud Healthcare Transferencia de mensajes de Healthcare HL7v2
  5. Si deseas habilitar la supervisión, selecciona la siguiente función adicional:

    • Monitoring > Supervisar la métrica escrita
  6. Haga clic en Crear.

gcloud

  1. Para crear la cuenta de servicio, ejecuta el comando gcloud iam service-accounts create:

    gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
    

    El resultado es la cuenta de servicio:

    Created service account SERVICE_ACCOUNT_NAME.
    
  2. Para otorgar cada función a la cuenta de servicio, ejecuta el comando gcloud projects add-iam-policy-binding.

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

    En el resultado, se incluye la política actualizada:

    bindings:
        - members:
            - user:SERVICE_ACCOUNT_NAME
            role: roles/pubsub.publisher
        - members:
            - user:SERVICE_ACCOUNT_NAME
            roles/healthcare.hl7V2Ingest
        - members:
            - user:SERVICE_ACCOUNT_NAME
            roles/monitoring.metricWriter
        etag: ETAG
        version: 1
    
  3. Para crear una clave de cuenta de servicio, ejecuta el comando gcloud iam service-accounts keys create.

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

    Una vez creada la cuenta de servicio, un archivo de claves JSON que contiene las credenciales de la cuenta de servicio se descarga en tu computadora. Usarás este archivo de claves para configurar el adaptador de MLLP a fin de autenticarte en la API de Cloud Healthcare, la API de Pub/Sub y la API de Cloud Monitoring meidante la marca --service-account durante la creación del clúster.

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

Cómo crear el clúster

Para crear el clúster en GKE, ejecuta el comando gcloud container clusters create:

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

Donde:

  • COMPUTE_ZONE es la zona en la que se implementa tu clúster. Una zona es una ubicación regional aproximada en la que residen tus clústeres y sus recursos. Por ejemplo, us-west1-a es una zona en la región us-west. Si estableciste una zona predeterminada con gcloud config set compute/zone, el valor de esta marca anula el predeterminado.
  • CLIENT_EMAIL es el identificador de la cuenta de servicio. Puedes encontrar esta dirección de correo electrónico en el archivo de claves de la cuenta de servicio en el campo "client_email":. Tiene el formato SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.

El comando muestra un resultado similar al siguiente ejemplo:

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

Después de crear el clúster, GKE crea tres instancias de VM de Compute Engine. Para verificarlo, genere una lista de las instancias con el siguiente comando:

gcloud compute instances list

Configura la implementación

Cuando implementas una aplicación en GKE, debes definir propiedades de la implementación mediante un archivo de manifiesto de implementación, que suele ser un archivo YAML. Para obtener una muestra, consulta Crea una implementación.

  1. Abre otra terminal.

  2. Mediante un editor de texto, crea un archivo de manifiesto de implementación llamado mllp_adapter.yaml con el siguiente contenido:

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

Donde:

  • PROJECT_ID es el ID del proyecto de Google Cloud que contiene tu almacén HL7v2.
  • LOCATION es la región en la que se encuentra tu almacén HL7v2.
  • DATASET_ID es el ID del conjunto de datos superior de tu almacén HL7v2.
  • HL7V2_STORE_ID es el ID de la tienda HL7v2 al que envías mensajes HL7v2.
  • RECEIVER_IP es la dirección IP del centro de atención de origen. Si realizas pruebas con una máquina local que actúe como centro de atención médica, configura RECEIVER_IP como 0.0.0.0.

La implementación tiene las siguientes propiedades:

  • spec: replicas: es la cantidad de pods replicados que administra la implementación.
  • spec: template: metadata: labels: es la etiqueta asignada a cada pod, que la implementación usa para administrar los pods.
  • spec: template: spec: es la especificación de pod, que define cómo debe ejecutarse cada pod.
  • spec: containers incluye el nombre del contenedor que se ejecutará en cada pod y la imagen de contenedor que se debe ejecutar.

Para obtener más información sobre la especificación de implementación, consulta la referencia de la API de Deployment.

Configura el servicio

A fin de que el adaptador de MLLP sea accesible para las aplicaciones fuera del clúster (como un centro de atención), debes configurar un balanceador de cargas interno.

Si no configuraste una VPN, las aplicaciones pueden acceder al adaptador de MLLP a través del balanceador de cargas interno, siempre que las aplicaciones usen la misma red de VPC y se encuentren en la misma región de Google Cloud. Por ejemplo, a fin de que el adaptador sea accesible para una instancia de VM de Compute Engine en la misma región y en la misma red de VPC, puedes agregar un balanceador de cargas interno al recurso del servicio del clúster.

En el directorio en el que creaste el archivo de manifiesto de implementación, usa el editor de texto para crear un archivo de manifiesto de servicio llamado mllp_adapter_service.yaml con el siguiente contenido. Este archivo es responsable de configurar el balanceo de cargas 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

El Service tiene las siguientes propiedades:

  • metadata: name: es el nombre que eliges para el servicio. En este caso, es mllp-adapter-service.
  • metadata: annotations: es una anotación que especifica que se debe configurar un balanceador de cargas interno.
  • spec: type: es el tipo de balanceador de cargas.
  • ports: port: se usa para especificar el puerto en el que el servicio puede recibir tráfico de otros servicios en el mismo clúster. Se usa el puerto MLLP predeterminado de 2575.
  • ports: targetPort: se usa para especificar el puerto en cada Pod en el que se ejecuta el servicio.
  • spec: selector: app: especifica los Pods a los que se orienta el Service.

Aunque es posible especificar una dirección IP para el balanceador de cargas (con el usoclusterIP campo ), el balanceador de cargas puede generar su propia dirección IP a la que puedas enviar mensajes. Por ahora, permite que el clúster genere la dirección IP, que usarás más adelante en este instructivo.

Para obtener más información sobre el balanceo de cargas interno, consulta la documentación de GKE.

Para obtener más información sobre la especificación del servicio, consulta la referencia de la API de servicio.

Implementa la implementación

Para implementar el adaptador en un clúster de GKE, en el directorio que contiene el archivo de manifiesto de implementación mllp_adapter.yaml, ejecuta el siguiente comando:

kubectl apply -f mllp_adapter.yaml

El comando muestra el siguiente resultado:

deployment.extensions "mllp-adapter-deployment" created

Inspecciona la implementación

Después de crear la implementación, puedes usar la herramienta de kubectl para inspeccionarla.

Para obtener información detallada sobre la implementación, ejecuta el siguiente comando:

kubectl describe deployment mllp-adapter

Para enumerar el Pod creado por la implementación, ejecuta el siguiente comando:

kubectl get pods -l app=mllp-adapter

Para obtener información sobre el Pod creado, sigue estos pasos:

kubectl describe pod POD_NAME

Si la implementación se realizó de forma correcta, la última parte del resultado del comando anterior debe contener la siguiente información:

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

Implementa el servicio y crea el balanceador de cargas interno

Para crear el balanceador de cargas interno, en el directorio que contiene el archivo de manifiesto del Service mllp_adapter_service.yaml, ejecuta el siguiente comando:

kubectl apply -f mllp_adapter_service.yaml

El comando muestra el siguiente resultado:

service "mllp-adapter-service" created

Inspecciona el servicio

Después de crear el servicio, inspecciónalo para verificar que se haya configurado correctamente.

Para inspeccionar el balanceador de cargas interno, ejecuta el siguiente comando:

kubectl describe service mllp-adapter-service

El resultado del comando es similar al siguiente ejemplo:

Name:                     mllp-adapter-service
Namespace:                default
Labels:                   <none>
Annotations:              cloud.google.com/load-balancer-type=Internal
                          kubectl.kubernetes.io/last-applied-configuration={"apiVersion":"v1","kind":"Service","metadata":{"annotations":{"cloud.google.com/load-balancer-type":"Internal"},"name":"mllp-adapter-service","namespa...
Selector:                 app=mllp-adapter
Type:                     LoadBalancer
IP:                       203.0.113.1
LoadBalancer Ingress:     203.0.113.1
Port:                     port  2575/TCP
TargetPort:               2575/TCP
NodePort:                 port  30660/TCP
Endpoints:                <none>
Session Affinity:         None
External Traffic Policy:  Cluster
Events:
  Type    Reason                Age   From                Message
  ----    ------                ----  ----                -------
  Normal  EnsuringLoadBalancer  1m    service-controller  Ensuring load balancer
  Normal  EnsuredLoadBalancer   1m    service-controller  Ensured load balancer

La dirección IP de LoadBalancer Ingress puede tardar hasta un minuto en propagarse. Usarás esta dirección IP y el puerto 2575 para acceder al Service desde fuera del clúster en el paso siguiente.

Crea una VM de Compute Engine y envía mensajes

Más adelante en este instructivo, probaste el adaptador de MLLP de manera local y enviaste mensajes HL7v2 a tu almacén HL7v2, ahora enviarás mensajes desde una VM de Compute Engine al adaptador de AAML que se ejecuta en GKE. Luego, los mensajes se reenvían a un almacén HL7v2.

Para enviar solicitudes de la instancia nueva al clúster de GKE, la instancia y las instancias existentes deben estar en la misma región y usar la misma red de VPC.

Al final de esta sección, enumerarás las notificaciones publicadas en tu tema de Pub/Sub y los mensajes de HL7v2 en tu almacén de HL7v2. La instancia de VM de Compute Engine debe tener permisos para realizar estas tareas. Antes de crear la instancia, sigue estos pasos para crear una cuenta de servicio nueva con los permisos necesarios:

Console

  1. En Cloud Console, ve a la página Crea una clave de cuenta de servicio.

    Ir a la página Crear clave de la cuenta de servicio

  2. En la lista Cuenta de servicio, selecciona Cuenta de servicio nueva.

  3. Ingresa un nombre en el campo Nombre de cuenta de servicio.

  4. En la lista Función, selecciona las dos siguientes funciones:

    • Pub/Sub > Suscriptor de Pub/Sub
    • Cloud Healthcare > Consumidor de mensajes HL7v2 de Healthcare
  5. Haga clic en Crear.

Una vez creada la cuenta de servicio, un archivo de claves JSON que contiene las credenciales de la cuenta de servicio se descarga en tu computadora.

gcloud

  1. Para crear la cuenta de servicio, ejecuta el comando gcloud iam service-accounts create:

    gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
    

    El resultado es la cuenta de servicio:

    Created service account SERVICE_ACCOUNT_NAME.
    
  2. Para otorgar cada función a la cuenta de servicio, ejecuta el 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
    

    En el resultado, se incluye la política actualizada:

    bindings:
        - members:
            - user:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
            role: roles/pubsub.publisher
        - members:
            - user:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
            roles/healthcare.hl7V2Consumer
        etag: ETAG
        version: 1
    
  3. Para crear una clave de cuenta de servicio, ejecuta el comando gcloud iam service-accounts keys create.

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

    Una vez creada la cuenta de servicio, un archivo de claves JSON que contiene las credenciales de la cuenta de servicio se descarga en tu computadora.

En los siguientes pasos, se muestra cómo crear una instancia de máquina virtual de Linux en Compute Engine:

Console

  1. En Cloud Console, ve a la página Instancias de VM.

    Ir a la página Instancias de VM

  2. Haga clic en Crear instancia.

  3. Elige una región y zona para la instancia que coincide con la zona que seleccionaste cuando creaste el clúster. Por ejemplo, si usasteus-central1-a para laCOMPUTE_ZONE cuando creaste el clúster y, en la pantalla de creación de instancias, seleccionaus-central1 (Iowa) para laRegión comous-central1-a para laZona las rutas "a GCP".

  4. En la sección Disco de arranque, haz clic en Cambiar para configurar el disco de arranque.

  5. En la pestaña Imágenes públicas, selecciona la versión 9 del sistema operativo Debian.

  6. Haga clic en Seleccionar.

  7. En la sección Identidad y acceso a la API, selecciona la cuenta de servicio que creaste.

  8. En la sección Firewall, selecciona Permitir el tráfico HTTP.

  9. Haga clic en Crear para crear la instancia.

gcloud

Para crear una instancia de procesamiento, ejecuta el método gcloud compute instances create con las siguientes opciones:

  • La ZONE que seleccionaste cuando creaste el clúster
  • La etiqueta http-server para permitir el tráfico HTTP
  • El SERVICE_ACCOUNT que creaste
gcloud compute instances create COMPUTE_NAME \
   --project=PROJECT_ID \
   --zone=ZONE \
   --image-family=debian-9 \
   --image-project=debian-cloud \
   --tags=http-server \
   --service-account=SERVICE_ACCOUNT

El resultado es similar al siguiente ejemplo:

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

La instancia tardará unos momentos en iniciarse. Una vez que se inicia la instancia, se mostrará en la página Instancias de VM con un ícono de estado verde.

De forma predeterminada, la instancia usa la misma red de VPC predeterminada que usa el clúster, lo que significa que el tráfico se puede enviar desde la instancia al clúster.

Para conectarte a la instancia, completa los siguientes pasos:

Console

  1. En Cloud Console, ve a la página Instancias de VM.

    Ir a la página Instancias de VM

  2. En la lista de instancias de máquina virtual, haz clic en SSH en la fila de la instancia que creaste.

gcloud

Para conectarte a la instancia, ejecuta el comando gcloud compute ssh:

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

Ahora tienes una ventana de la terminal para interactuar con tu instancia de Linux.

  1. En la ventana de la terminal, instala Netcat:

    sudo apt install netcat
    
  2. Descarga el archivo hl7v2-mllp-sample.txt y guárdalo en la instancia. Para obtener información sobre los evaluadores de codificación y segmento que se usan en el archivo, consulta los separadores de segmentos de mensajes de HL7v2 y la codificación.

  3. Para comenzar a enviar mensajes HL7v2 a través del adaptador de MLLP a tu almacén de HL7v2, en el directorio donde descargaste el archivo, ejecuta el siguiente comando. Usa el valor de LoadBalancer Ingress que se mostró cuando inspeccionaste el Service.

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

    Después de ejecutar el comando, el mensaje se envía a través del adaptador de MLLP a tu almacén de HL7v2. Si el mensaje se transfirió correctamente al almacén de HL7v2, el comando mostrará el siguiente resultado:

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

    Este resultado indica que la tienda HL7v2 respondió con un tipo de respuesta AA (Application Accept), lo que significa que el mensaje se valida y se transfiere correctamente.

  4. Para ver el mensaje publicado en el tema de Pub/Sub, ejecuta el comando gcloud pubsub subscriptions pull:

    gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION
    

    El comando muestra el siguiente resultado sobre el mensaje HL7v2 transferido:

    ┌-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┐
    |                                                               DATA                                              |    MESSAGE_ID   |   ATTRIBUTES  |
    ├-----------------------------------------------------------------------------------------------------------------|-----------------|---------------|
    | projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/HL7V2_MESSAGE_ID | 123456789012345 | msgType=ADT   |
    └-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘
    
  5. También puedes enumerar los mensajes en tu almacén HL7v2 para ver si el mensaje se agregó:

    curl

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

    Si la solicitud es exitosa, el servidor muestra el ID del mensaje en una ruta del recurso:

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

    PowerShell

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

    Si la solicitud es exitosa, el servidor muestra el ID del mensaje en una ruta del recurso:

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

Después de completar esta sección, implementaste correctamente el adaptador de MLLP en GKE y enviaste un mensaje HL7v2 desde una instancia remota a través del adaptador y la API de Cloud Healthcare.

En el resto de este instructivo, aprenderás a encriptar de manera segura los mensajes HL7v2 transmitidos mediante la configuración de una VPN entre una instancia de Compute Engine, que actúa como una instancia “local” y el adaptador.

Configura una VPN

El uso de una VPN te permite extender la red privada en la que envías mensajes HL7v2 a través de una red pública, como Internet. Cuando usas una VPN, puedes enviar mensajes desde tu centro de atención médica mediante el adaptador MLLP y Google Cloud. Los sistemas en este flujo actúan como si estuvieran en una sola red privada.

Hay dos métodos para proteger tu conexión MLLP mediante VPN:

Configura Cloud VPN

Cloud VPN conecta de forma segura tu red local a tu red de nube privada virtual (VPC) de Google Cloud a través de una conexión de VPN IPsec. Una puerta de enlace VPN encripta el tráfico que viaja entre las dos redes; luego, la otra puerta de enlace VPN lo desencripta. Esto protege tus datos mientras viajan por Internet o a través de una red de centros de atención.

En este instructivo, cada puerta de enlace VPN que configuras se encuentra en una red y subred personalizadas diferentes en una región de Google Cloud diferente.

La puerta de enlace VPN configurada en us-central1 actúa como la puerta de enlace de Cloud VPN en el lado de Google Cloud, mientras que la puerta de enlace de Cloud VPN en europe-west1 simula tu puerta de enlace “local”.

Referencia de nombres y direcciones

Como referencia, en este instructivo se usan los siguientes nombres y direcciones IP:

Lado de Google Cloud

  • Nombre de la red: cloud-vpn-network
  • Nombre de la subred: subnet-us-central-10-0-1
  • Región: us-central1
  • Rango de subred: 10.0.1.0/24
  • Nombre de la dirección IP externa: cloud-vpn-ip
  • Nombre de puerta de enlace de VPN: vpn-us-central
  • Nombre de túnel VPN: vpn-us-central-tunnel-1

Lado "local"

  • Nombre de la red: on-prem-vpn-network
  • Nombre de la subred: subnet-europe-west-10-0-2
  • Región: europe-west1
  • Rango de subred: 10.0.2.0/24
  • Nombre de la dirección IP externa: on-prem-vpn-ip
  • Nombre de puerta de enlace de VPN: vpn-europe-west
  • Nombre de túnel VPN: vpn-europe-west-tunnel-1

Crea redes y subredes de VPC personalizadas

El primer paso para configurar Cloud VPN es crear dos redes de VPC. Una red, llamada on-prem-vpn-network, se configura en el entorno "local" y se ejecuta en una instancia de VM de Compute Engine llamada on-prem-instance. La otra red, llamada cloud-vpn-network, es lo que usa el clúster de GKE que ejecuta el adaptador de MLLP. Te conectarás a la VM on-prem-instance y enviarás HL7v2 al adaptador MLML que se ejecuta bajo la red cloud-vpn-network a través del balanceador de cargas interno del adaptador MLLP.

Para crear dos redes de VPC personalizadas y sus subredes, completa los siguientes pasos:

  1. Para crear la primera red de VPC, cloud-vpn-network, ejecuta el siguiente comando:

    gcloud compute networks create cloud-vpn-network \
       --project=PROJECT_ID \
       --subnet-mode=custom
    
  2. A fin de crear la subred subnet-us-central-10-0-1 para la red cloud-vpn-network, ejecuta el siguiente comando:

    gcloud compute networks subnets create subnet-us-central-10-0-1 \
       --project=PROJECT_ID \
       --region=us-central1 \
       --network=cloud-vpn-network \
       --range=10.0.1.0/24
    
  3. Para crear la red de VPC on-prem-vpn-network, ejecuta el siguiente comando:

    gcloud compute networks create on-prem-vpn-network \
       --project=PROJECT_ID \
       --subnet-mode=custom
    
  4. A fin de crear la subred subnet-europe-west-10-0-2 para la red de VPC on-prem-vpn-network, ejecuta el siguiente 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
    

Crea una dirección IP externa

Antes de crear las puertas de enlace VPN, sigue estos pasos para reservar una dirección IP externa:

  1. A fin de reservar una dirección IP externa regional (estática) para la dirección cloud-vpn-ip, ejecuta el siguiente comando:

    gcloud compute addresses create cloud-vpn-ip \
       --project=PROJECT_ID \
       --region=us-central1
    
  2. A fin de reservar una dirección IP externa regional (estática) para la dirección on-prem-vpn-ip, ejecuta el siguiente comando:

    gcloud compute addresses create on-prem-vpn-ip \
       --project=PROJECT_ID \
       --region=europe-west1
    
  3. Toma nota de las direcciones IP externas a fin de que puedas usarlas para configurar las puertas de enlace de VPN en la siguiente sección. Para recuperar las direcciones IP externas, ejecuta el siguiente comando:

    Dirección IP de Cloud VPN:

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

    Dirección IP de VPN “local”:

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

    Los comandos muestran un resultado similar al siguiente:

    address: 203.0.113.1
    

Crea túneles, rutas y puertas de enlace VPN

Completa los siguientes pasos a fin de crear la puerta de enlace, el túnel y la ruta de VPN para Cloud VPN:

  1. Sigue las instrucciones en Genera una clave precompartida segura para crear una clave precompartida criptográficamente segura. Esta clave se hace referencia a SHARED_SECRET en esta sección.

  2. Para crear el objeto puerta de enlace VPN de destino, ejecuta el siguiente comando:

    gcloud compute target-vpn-gateways create vpn-us-central \
       --project PROJECT_ID \
       --region us-central1 \
       --network cloud-vpn-network
    
  3. Para crear tres reglas de reenvío, ejecuta los siguientes comandos y reemplaza la variable CLOUD_VPN_EXTERNAL_ADDRESS por el valor de la dirección IP de Cloud VPN en la sección anterior:

    Envía tráfico de ESP (IPsec) a la puerta de enlace:

    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
    

    Envía tráfico UDP 500 a la puerta de enlace:

    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
    

    Envía tráfico UDP 4,500 a la puerta de enlace:

    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. Para crear un túnel en la puerta de enlace de Cloud VPN, ejecuta el siguiente comando. Reemplaza ON_PREM_VPN_IP por el valor de la dirección IP de VPN “local” en la sección anterior.

    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. A fin de crear una ruta estática para 10.0.2.0/24, ejecuta el siguiente 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 los siguientes pasos a fin de crear la puerta de enlace VPN, el túnel y la ruta para la VPN “local”:

  1. Para crear el objeto puerta de enlace VPN de destino, ejecuta el siguiente comando:

    gcloud compute target-vpn-gateways create "vpn-europe-west" \
       --project PROJECT_ID \
       --region "europe-west1" \
       --network "on-prem-vpn-network"
    
  2. Para crear tres reglas de reenvío, ejecuta los siguientes comandos y reemplaza la variable ON_PREMISES_VPN_EXTERNAL_ADDRESS por el valor de la dirección IP VPN “local” de la sección anterior:

    Envía tráfico de ESP (IPsec) a la puerta de enlace:

    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
    

    Envía tráfico UDP 500 a la puerta de enlace:

    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
    

    Envía tráfico UDP 4,500 a la puerta de enlace:

    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. Para crear un túnel en la puerta de enlace “local”, ejecuta el siguiente comando:

    gcloud compute vpn-tunnels create vpn-europe-west-tunnel-1 \
       --project PROJECT_ID \
       --region europe-west1 \
       --peer-address CLOUD_VPN_IP \
       --shared-secret SHARED_SECRET \
       --ike-version 2 \
       --local-traffic-selector 0.0.0.0/0 \
       --target-vpn-gateway vpn-europe-west
    
  4. A fin de crear una ruta estática para 10.0.1.0/24, ejecuta el siguiente 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"
    

Has creado las puertas de enlace de Cloud VPN y las puertas de enlace "locales", y, también, iniciaste sus túneles. Las puertas de enlace de VPN no se conectarán hasta que hayas creado reglas de firewall para permitir el tráfico a través del túnel entre ellas.

Crea reglas de firewall

Debes crear reglas de firewall para ambos lados del túnel VPN. Estas reglas permiten que todo el tráfico de TCP, ICMP y UDP ingrese desde la subred en un lado del túnel VPN hasta el otro.

  1. A fin de crear las reglas de firewall para la subred de Cloud VPN, ejecuta el siguiente 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. Para crear las reglas de firewall de la subred “local”, ejecuta el siguiente 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 regla de firewall que te permita establecer una conexión SSH a la instancia de VM en el puerto 22 mediante la ejecución del siguiente comando:

    gcloud compute firewall-rules create on-prem-vpn-allow-ssh \
       --project=PROJECT_ID \
       --direction=INGRESS \
       --priority=1000 \
       --network=on-prem-vpn-network \
       --action=ALLOW \
       --rules=tcp:22 \
       --source-ranges=0.0.0.0/0
    

Verifica el estado del túnel VPN

Para verificar que tu túnel esté activo, completa los siguientes pasos:

  1. Ve a la página de VPN en Cloud Console.

    Ir a la página de VPN

  2. Haz clic en la pestaña Túneles de VPN de Google.

  3. En el campo Estado de cada túnel, busca una marca de verificación verde y la palabra "Establecido". Si estos elementos están allí, tus puertas de enlace negociaron un túnel. Si no aparece una marca después de unos minutos, consulta Solución de problemas.

    Para obtener información de registro adicional relacionada con tus túneles VPN, consulta Comprobación de registros VPN en la página Solución de problemas. Por ejemplo, puedes ver las métricas sobre los paquetes descartados, el estado del túnel, los bytes recibidos y los bytes enviados.

Ahora que configuraste Cloud VPN correctamente con las puertas de enlace, los túneles y las reglas de firewall necesarias, puedes crear una conexión segura entre la instancia de VM “local” y el adaptador de MLLP que se ejecuta en GKE.

Combina la implementación en GKE y Cloud VPN

Antes en este instructivo probaste el adaptador de MLLP de forma local y enviaste mensajes HL7v2 a través de una conexión que no es de VPN al adaptador de MLLP, ahora enviarás mensajes desde una VM de Compute Engine a través de una conexión segura mediante Cloud VPN al adaptador MLLP que se ejecuta en GKE. Luego, los mensajes se reenvían a un almacén HL7v2.

Vuelve a crear la implementación

Primero, vuelve a crear la implementación en GKE para que el clúster use los parámetros que configuraste en Configuración de Cloud VPN:

  1. Para borrar el clúster mllp-adapter que creaste, ejecuta el comando gcloud container clusters delete. Ingresa el valor COMPUTE_ZONE que usaste cuando creaste el clúster.

    gcloud container clusters delete mllp-adapter --zone=COMPUTE_ZONE
    
  2. Sigue los pasos en Implementa el adaptador de MLLP en Kubernetes Engine, pero cuando crees el clúster en GKE, agrega la red cloud-vpn-network y la subred subnet-us-central-10-0-1 que creaste en Crea redes y subredes VPN personalizadas.

    Asegúrate de que el comando de creación del clúster se vea de la siguiente manera:

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

    Donde:

    • COMPUTE_ZONE es la zona en la que se implementa tu clúster. Cuando configuraste Cloud VPN en la sección anterior, configura la red del “GCP” para que use us-central1. Esta red “en GCP” es en la que se ejecuta el clúster de GKE. Usa cualquiera de las siguientes zonas en us-central1: us-central1-c, us-central1-a, us-central1-f, us-central1-b.

    • CLIENT_EMAIL es el identificador de la cuenta de servicio. Puedes encontrarlo en el archivo de claves de la cuenta de servicio en el campo "client_email":. Toma el formato SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.

Crea una nueva VM de Compute Engine con la configuración de red

En los siguientes pasos, se muestra cómo crear una instancia de máquina virtual de Linux en Compute Engine con Cloud Console. A diferencia de la VM de Compute Engine que creaste, esta VM usa la configuración de red “del lado local” para comunicarse con el clúster de GKE a través de una VPN.

Console

  1. En Cloud Console, ve a la página Instancias de VM.

    Ir a la página Instancias de VM

  2. Haga clic en Crear instancia.

  3. Elige un Región y Zona para la instancia que coincide con la configuración de red del “lado local”: europe-west1 (Belgium) para la Región y europe-west1-b la Zona.

  4. En la sección Boot disk, haga clic en Change para configurar el disco de arranque.

  5. En la pestaña Imágenes públicas, selecciona la versión 9 del sistema operativo Debian.

  6. Haga clic en Seleccionar.

  7. En la sección Identidad y acceso a la API, selecciona la cuenta de servicio que creaste.

  8. En la sección Firewall, selecciona Permitir el tráfico HTTP.

  9. Expande la sección Administración, seguridad, discos, redes, instancia única.

  10. En Interfaces de red en la pestaña Herramientas de redes, especifica los detalles de red para la configuración de red “del lado local”:

    1. En el campo Red, selecciona on-prem-vpn-network.
    2. En el campo Subred, seleccione subnet-europe-west-10-0-2 (10.0.2.0/24).
  11. Haga clic en Crear para crear la instancia.

La instancia tardará unos momentos en iniciarse. Cuando esté lista, aparecerá en la página de instancias de VM con un ícono de estado verde.

gcloud

Para crear una instancia de procesamiento, ejecuta el método gcloud compute instances create con las siguientes opciones:

  • El ZONE que coincide con la configuración de red “del lado local”: europe-west1-b para la Zona.
  • Permite el tráfico HTTP mediante la especificación de la etiqueta http-server
  • El SERVICE_ACCOUNT que creaste
gcloud compute instances create COMPUTE_NAME \
   --project=PROJECT_ID
   --zone=ZONE
   --image-family=debian-9 \
   --tags=http-server,https-server
   --service-account=SERVICE_ACCOUNT

El resultado es similar al siguiente ejemplo:

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

Para conectarte a la instancia, completa los siguientes pasos:

Console

  1. En Cloud Console, ve a la página Instancias de VM.

    Ir a la página Instancias de VM

  2. En la lista de instancias de máquina virtual, haz clic en SSH en la fila de la instancia que creaste.

gcloud

Para conectarte a la instancia, ejecuta el comando gcloud compute ssh:

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

Ahora tienes una ventana de la terminal para interactuar con tu instancia de Linux.

  1. En la ventana de la terminal, instala Netcat:

    sudo apt install netcat
    
  2. Descarga el archivo hl7v2-mllp-sample.txt y guárdalo en la instancia.

  3. Para comenzar a enviar mensajes HL7v2 a través del adaptador de MLLP a tu almacén de HL7v2, en el directorio donde descargaste el archivo, ejecuta el siguiente comando. Usa el valor de LoadBalancer Ingress que se mostró cuando inspeccionaste el Service.

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

    Después de ejecutar el comando, el mensaje se envía a través del adaptador de MLLP a tu almacén de HL7v2. Si el mensaje se transfirió correctamente al almacén de HL7v2, el comando mostrará el siguiente resultado:

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

    Este resultado indica que la tienda HL7v2 respondió con un tipo de respuesta AA (Application Accept), lo que significa que el mensaje se valida y se transfiere correctamente.

  4. Para ver el mensaje publicado en el tema de Pub/Sub, ejecuta el comando gcloud pubsub subscriptions pull:

    gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION
    

    El comando muestra el siguiente resultado sobre el mensaje HL7v2 transferido:

    ┌-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┐
    |                                                               DATA                                              |    MESSAGE_ID   |   ATTRIBUTES  |
    ├-----------------------------------------------------------------------------------------------------------------|-----------------|---------------|
    | projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/HL7V2_MESSAGE_ID | 123456789012345 | msgType=ADT   |
    └-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘
    
  5. También puedes enumerar los mensajes en tu almacén HL7v2 para ver si el mensaje se agregó:

    curl

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

    Si la solicitud es exitosa, el servidor muestra el ID del mensaje en una ruta del recurso:

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

    PowerShell

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

    Si la solicitud es exitosa, el servidor muestra el ID del mensaje en una ruta de recursos:

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

Después de completar esta sección, implementaste correctamente el adaptador de MLLP en GKE y, mediante una VPN, enviaste de forma segura un mensaje HL7v2 desde una instancia “local” a través del adaptador y a la API de Cloud Healthcare.

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos utilizados en este instructivo, puedes limpiar los recursos que creaste en Google Cloud.

Borra el proyecto

Sigue los pasos a continuación para borrar el proyecto que creaste en este instructivo:

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a Administrar recursos

  2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
  3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Soluciona problemas

Fallas del adaptador

Después de implementar el adaptador de MLLP en GKE, el adaptador encuentra una falla.

Error Connection refused cuando se ejecuta de manera local

Cuando pruebas el adaptador de MLLP de forma local, experimentas un error Connection refused.

  • Este error ocurre con algunos usuarios de Mac OS. En lugar de usar la marca --network=host, usa -p 2575:2575. Además, en lugar de configurar --receiver_ip=127.0.0.0, configura --receiver_ip=0.0.0.0. El comando debería verse así:

    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
    

Error could not find default credentials cuando se ejecuta de manera local

Cuando pruebas el adaptador de MLLP de forma local, experimentas un error healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials. See https://developers.google.com/accounts/docs/application-default-credentials for more information..

Este error se produce cuando el adaptador no puede encontrar tus credenciales de Google Cloud. Para corregir el error, prueba uno de los siguientes métodos antes de volver a ejecutar el comando:

Errores de autenticación

Si encuentras errores de autenticación cuando pruebas el adaptador del MLLP de forma local que no se incluyen en el resto de esta sección, vuelve a ejecutar el comando docker run y agrega la -v ~/.config:/root/.config al final del comando, de la siguiente manera:

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