Como transmitir mensagens HL7v2 por conexões TCP/IP

Este tutorial fornece instruções para a transmissão de mensagens HL7v2 por conexões TCP/IP usando o protocolo de camada mínima (MLLP, na sigla em inglês). Para exigir que a imagem MLLP seja assinada por um atestador, siga as etapas em Como transmitir mensagens HL7v2 por conexões TCP/IP usando uma imagem MLLP assinada.

Neste tutorial, fornecemos instruções para executar o adaptador MLLP de código aberto hospedados no GitHub nos seguintes ambientes:

• Localmente/no local
• Em um contêiner no GKE com o Cloud VPN
• Em um contêiner no GKE sem o Cloud VPN.

Objetivos

Depois de concluir este tutorial, você saberá:

• Crie e configure localmente o adaptador MLLP com a API Cloud Healthcare e teste o envio de mensagens HL7v2 para um armazenamento HL7v2.
• Implante o adaptador MLLP no GKE e envie mensagens HL7v2 de uma instância de VM do Compute Engine.
• Configure uma VPN que proteja a conexão entre uma instância "local" e o adaptador MLLP e envie mensagens HL7v2 a partir da instância "local".

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

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

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Antes de começar

Antes de começar este tutorial, familiarize-se com a documentação conceitual sobre o protocolo mínimo da camada inferior (MLLP, na sigla em inglês) analisando o MLLP e o adaptador MLLP do Google Cloud. A documentação conceitual fornece uma visão geral do MLLP, como os sistemas de atendimento podem enviar e receber mensagens de e para a API Cloud Healthcare por meio de uma conexão MLLP e os princípios básicos da segurança do MLLP.

Antes de configurar o adaptador MLLP, escolha ou crie um projeto do Google Cloud e ative as APIs necessárias seguindo estas etapas:

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

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

   Go to project selector

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

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

   Enable the APIs

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

   Go to project selector

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

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

   Enable the APIs

8. Aguarde a ativação da Kubernetes Engine API e dos serviços relacionados. Isso pode levar alguns minutos.

Como escolher um shell

Para concluir este tutorial, use o Cloud Shell ou o shell local.

O Cloud Shell é um ambiente de shell para gerenciar recursos hospedados no Google Cloud. O Cloud Shell vem pré-instalado com a gcloud CLI e kubectl . A CLI gcloud fornece a interface de linha de comando principal para o Google Cloud. kubectl fornece a interface de linha de comando para a execução de comandos em clusters do GKE.

Se preferir usar seu shell local, instale o CLI gcloud.

Para abrir o Cloud Shell ou configurar o shell local, siga estas etapas:

Como criar um conjunto de dados

Se você ainda não criou um conjunto de dados da API Cloud Healthcare, crie um conjunto de dados concluindo as seguintes etapas:

gcloud healthcare datasets create DATASET_ID \
    --location=LOCATION

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

Como criar um tópico e uma assinatura do Pub/Sub

Para receber notificações quando as mensagens são criadas ou ingeridas, você precisa configurar um tópico do Pub/Sub com seu armazenamento HL7v2. Para mais informações, consulte Como configurar notificações do Pub/Sub.

Para criar um tópico, siga estas etapas:

gcloud pubsub topics create projects/PROJECT_ID/topics/TOPIC_NAME

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

Para criar uma assinatura, conclua as etapas a seguir:

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

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

Como criar um armazenamento HL7v2 configurado com um tópico do Pub/Sub

Crie um armazenamento HL7v2 e configure-o com um tópico do Pub/Sub. Para criar um armazenamento HL7v2, você precisa criar um conjunto de dados. Para os fins deste tutorial, use o mesmo projeto para sua loja HL7v2 e para o tópico do Pub/Sub.

Para criar um armazenamento HL7v2 configurado com um tópico do Pub/Sub, siga estas etapas:

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"

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

$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

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

Configurar permissões do Pub/Sub

Para enviar notificações ao Pub/Sub quando uma mensagem HL7v2 é criada ou processada, você precisa configurar as permissões do Pub/Sub na API Cloud Healthcare. Essa etapa precisa ser feita uma vez por projeto.

Para adicionar o papel pubsub.publisher necessário à conta de serviço do projeto, siga estas etapas:

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

Como extrair a imagem pré-criada do Docker

O adaptador MLLP é um aplicativo em contêiner testado em uma imagem do Docker pré-criada no Container Registry.

Para extrair a versão mais recente da imagem, execute o seguinte comando:

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

Como testar o adaptador MLLP localmente

Ao testar o adaptador localmente, você pode configurá-lo para ser executado como um destinatário, um editor ou ambos. As configurações do receptor e do editor têm as seguintes diferenças principais:

• Quando o adaptador é executado como um receptor, ele recebe mensagens HL7v2 de uma fonte externa e chama messages.ingest para ingerir as mensagens em um armazenamento HL7v2, criando uma notificação do Pub/Sub. A notificação é enviada para aplicativos inscritos no tópico Pub/Sub da loja HL7v2.
• Quando o adaptador é executado como editor, ele detecta mensagens HL7v2 criadas ou ingeridas em um armazenamento HL7v2 usando messages.create ou messages.ingest. Depois que uma mensagem é criada, uma notificação do Pub/Sub é enviada ao adaptador, e o adaptador publica as mensagens em um receptor externo.

As seções a seguir mostram como executar o adaptador para que ele atue como um destinatário ou um editor.

Depois de verificar se é possível executar o adaptador MLLP na máquina local, prossiga para a próxima seção em Como implantar o adaptador MLLP no Google Kubernetes Engine.

Como testar o adaptador MLLP localmente como um receptor

Quando o adaptador recebe uma mensagem HL7v2 de uma fonte externa, como uma central de atendimento, o adaptador chama messages.ingest e processa a mensagem HL7v2 no armazenamento HL7v2 configurado. Observe isso no código-fonte do adaptador.

Para testar o adaptador localmente como um receptor, siga estas etapas:

1. Na máquina em que você extraiu a imagem do Docker pré-criada, execute o seguinte 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

   onde:

   • PROJECT_ID é o código do projeto do Google Cloud que contém o armazenamento HL7v2.
   • LOCATION é a região em que sua loja HL7v2 está localizada;
   • DATASET_ID é o código do conjunto de dados pai do armazenamento HL7v2.
   • HL7V2_STORE_ID é o código do armazenamento HL7v2 para o qual você está enviando mensagens HL7v2.

   Depois de executar o comando anterior, o adaptador imprime uma mensagem semelhante à seguinte e começa a ser executada em sua máquina local no endereço IP de 127.0.0.1 na porta 2575:

   I0000 00:00:00.000000      1 healthapiclient.go:171] Dialing connection to https://healthcare.googleapis.com:443/v1
   I0000 00:00:00.000000      1 mllp_adapter.go:89] Either --pubsub_project_id or --pubsub_subscription is not provided, notifications of the new messages are not read and no outgoing messages will be sent to the target MLLP address.
   

   Se você encontrar algum erro, siga estas etapas de solução de problemas:

   • Se você estiver usando o Mac OS e o comando anterior falhar com um erro Connection refused, consulte Erro de conexão recusada durante a execução local.

   • Se o comando anterior falhar com um erro healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials. See https://developers.google.com/accounts/docs/application-default-credentials for more information., consulte could not find default credentials ao executar localmente.

   • Se você encontrar outros erros de autenticação, consulte Erros de autenticação.

2. Para continuar os testes enquanto o adaptador é executado como um processo em primeiro plano, abra um terminal diferente na máquina local.

3. No novo terminal, para instalar o Netcat, execute o seguinte comando:

   sudo apt install netcat
   

4. Faça o download do arquivo hl7v2-mllp-sample.txt e salve-o na máquina local.

5. Para enviar a mensagem HL7v2 ao adaptador, execute o comando a seguir no diretório em que você fez o download. O adaptador MLLP detecta seu host local na porta 2575. O comando envia a mensagem por meio do adaptador MLLP para seu armazenamento HL7v2.

   Linux

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

   Se a mensagem tiver sido processada com sucesso no armazenamento HL7v2, o comando retornará a seguinte saída:

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

   Essa saída indica que o armazenamento HL7v2 respondeu com um tipo de resposta AA (Application Accept), o que significa que a mensagem foi validada e processada.

6. Também é possível verificar se a mensagem foi enviada com êxito abrindo o terminal em que você executou o adaptador. A saída será semelhante à seguinte amostra:

    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. A mensagem é armazenada em seu armazenamento HL7v2, então você pode chamar messages.list para ver a mensagem:

   curl

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

   Se a solicitação for bem-sucedida, o servidor retornará o código da mensagem em um caminho de 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

   Se a solicitação for bem-sucedida, o servidor retornará o código da mensagem em um caminho de recurso:

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

Como testar o adaptador MLLP localmente como um editor

Ao testar o adaptador como editor, você cria mensagens chamando messages.create ou messages.ingest e fornecendo um arquivo de mensagem como dados binários.

O adaptador reconhece automaticamente as mensagens do Pub/Sub enviadas por messages.create e messages.ingest.

O adaptador notifica você quando busca e envia mensagens do Pub/Sub. Como o adaptador é um assinante do Pub/Sub, ele reconhece automaticamente essas mensagens. Como resultado, eles são removidos da fila de mensagens na assinatura do Pub/Sub que você configurou com o adaptador.

Para extrair da assinatura do Pub/Sub e verificar separadamente se as mensagens foram publicadas, você precisa criar uma segunda assinatura do Pub/Sub atribuída ao tópico criado anteriormente. As mensagens enviadas para a segunda assinatura não são reconhecidas automaticamente pelo adaptador e permanecem para que você possa extraí-las.

Para criar uma segunda assinatura do Pub/Sub atribuída ao tópico criado anteriormente, siga estas etapas:

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

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

Para testar o adaptador localmente como editor, conclua as etapas a seguir na máquina em que você extraiu a imagem pré-criada do Docker:

1. Instale o Netcat:

   sudo apt install netcat
   

2. Faça o download do arquivo hl7v2-mllp-ack-sample.txt e salve-o na máquina local. O arquivo contém uma mensagem ACK que o adaptador exige como resposta quando tenta publicar uma mensagem.

3. Para permitir que o Netcat detecte conexões de entrada na porta 2525, execute o seguinte comando no diretório em que você fez o download.

   Linux

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

   Depois de iniciar o Netcat, uma mensagem de saída semelhante à seguinte amostra é exibida:

   listening on [any] 2525 ...
   

4. O Netcat é executado como um processo em primeiro plano. Portanto, para continuar o teste, abra um terminal diferente na máquina local.

5. Para iniciar o adaptador, execute o seguinte comando no novo terminal:

   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

   onde:

   • PROJECT_ID é o código do projeto do Google Cloud que contém o armazenamento HL7v2.
   • LOCATION é a região em que sua loja HL7v2 está localizada;
   • DATASET_ID é o código do conjunto de dados pai do armazenamento HL7v2.
   • HL7V2_STORE_ID é o código do armazenamento HL7v2 para o qual você está enviando mensagens HL7v2.
   • PROJECT_ID é o código do projeto do Google Cloud que contém o tópico do Pub/Sub.
   • PUBSUB_SUBSCRIPTION é o nome da primeira assinatura que você criou associada ao tópico do Pub/Sub. O adaptador consome mensagens dessa assinatura e as reconhece automaticamente. Portanto, para visualizar as mensagens publicadas no tópico, você precisa extrair mensagens da segunda assinatura criada anteriormente.

   Depois de executar o comando anterior, o adaptador começa a ser executado na máquina local com o endereço IP de 127.0.0.1 na porta 2575.

   Se você encontrar algum erro, siga estas etapas de solução de problemas:

   • Se você estiver usando o Mac OS e o comando anterior falhar com um erro Connection refused, consulte Erro de conexão recusada durante a execução local.

   • Se o comando anterior falhar com um erro healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials. See https://developers.google.com/accounts/docs/application-default-credentials for more information., consulte could not find default credentials ao executar localmente.

   • Se você encontrar outros erros de autenticação, consulte Erros de autenticação.

   O adaptador é executado como um processo em primeiro plano. Portanto, para continuar os testes, abra um terminal diferente na máquina local.

6. Faça o download do arquivo hl7v2-sample.json e salve-o na máquina local. No diretório em que você fez o download do arquivo, chame o método messages.create para criar a mensagem em um armazenamento HL7v2:

   curl

   Para criar uma mensagem HL7v2, faça uma solicitação POST e especifique as seguintes informações:

   • O nome do conjunto de dados pai
   • O nome do armazenamento HL7v2
   • Uma mensagem
   • Um token de acesso

   O exemplo a seguir mostra uma solicitação POST usando curl e um arquivo JSON de exemplo chamado hl7v2-sample.json.

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

   Se a solicitação for bem-sucedida, o servidor retornará a resposta no formato JSON:

   {
     "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
     "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZfEF8QXwyMDE4MDEwMTAwMDAwMHx8VFlQRV5BfDIwMTgwMTAxMDAwMDAwfFR8MC4wfHx8QUF8fDAwfEFTQ0lJDUVWTnxBMDB8MjAxODAxMDEwNDAwMDANUElEfHwxNAExMTFeXl5eTVJOfDExMTExMTExXl5eXk1STn4xMTExMTExMTExXl5eXk9SR05NQlI=",
     "sendFacility": "SEND_FACILITY",
     "sendTime": "2018-01-01T00:00:00Z",
     "messageType": "TYPE",
     "createTime": "1970-01-01T00:00:00Z",
     "patientIds": [
       {
         "value": "14\u0001111",
         "type": "MRN"
       },
       {
         "value": "11111111",
         "type": "MRN"
       },
       {
         "value": "1111111111",
         "type": "ORGNMBR"
       }
     ]
   }
   

   PowerShell

   Para criar uma mensagem HL7v2, faça uma solicitação POST e especifique as seguintes informações:

   • O nome do conjunto de dados pai
   • O nome do armazenamento HL7v2
   • Uma mensagem
   • Um token de acesso

   O exemplo a seguir mostra uma solicitação POST usando o Windows PowerShell e um arquivo JSON de exemplo chamado hl7v2-sample.json.

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

   Se a solicitação for bem-sucedida, o servidor retornará a resposta no formato JSON:

   {
     "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
     "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZfEF8QXwyMDE4MDEwMTAwMDAwMHx8VFlQRV5BfDIwMTgwMTAxMDAwMDAwfFR8MC4wfHx8QUF8fDAwfEFTQ0lJDUVWTnxBMDB8MjAxODAxMDEwNDAwMDANUElEfHwxNAExMTFeXl5eTVJOfDExMTExMTExXl5eXk1STn4xMTExMTExMTExXl5eXk9SR05NQlI=",
     "sendFacility": "SEND_FACILITY",
     "sendTime": "2018-01-01T00:00:00Z",
     "messageType": "TYPE",
     "createTime": "1970-01-01T00:00:00Z",
     "patientIds": [
       {
         "value": "14\u0001111",
         "type": "MRN"
       },
       {
         "value": "11111111",
         "type": "MRN"
       },
       {
         "value": "1111111111",
         "type": "ORGNMBR"
       }
     ]
   }
   

   Depois de criar a mensagem, o adaptador MLLP retorna uma resposta semelhante para o seguinte:

   I0214 00:00:00.000000       1 healthapiclient.go:244] Started to fetch message from the Cloud Healthcare API HL7V2 Store
   I0214 00:00:00.000000       1 healthapiclient.go:283] Message was successfully fetched from the Cloud Healthcare API HL7V2 Store.
   

7. No terminal em que você executou o Netcat, uma saída semelhante à amostra a seguir é exibida. Esta saída indica que a mensagem foi publicada:

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

   Isso corresponde ao valor no campo data da resposta que você recebeu quando criou a mensagem. É o mesmo que o valor data no arquivo hl7v2-sample.json.

8. Para ver a mensagem que o adaptador publicou no tópico do Pub/Sub, execute o comando gcloud pubsub subscriptions pull na segunda assinatura do Pub/Sub que você criou:

   gcloud pubsub subscriptions pull --auto-ack SECOND_SUBSCRIPTION

   O comando retorna a seguinte saída sobre a mensagem HL7v2 criada. Observe o valor publish=true na coluna ATTRIBUTES, que indica que a mensagem foi publicada no 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  |
   └-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘

Como publicar mensagens em diferentes receptores externos

Você pode configurar o armazenamento HL7v2 com vários tópicos do Pub/Sub e usar filtros para enviar notificações para diferentes tópicos do Pub/Sub. Você pode executar um adaptador MLLP para cada tópico do Pub/Sub para publicar as mensagens em um receptor externo diferente.

Para configurar o armazenamento HL7v2 com vários tópicos do Pub/Sub e um filtro para cada tópico, siga estas etapas:

1. Crie dois tópicos do Pub/Sub e uma assinatura para cada tópico. Para mais informações, consulte Como criar um tópico e uma assinatura do Pub/Sub.

2. Execute este comando:

   curl

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

   Se a solicitação for bem-sucedida, o servidor retornará a resposta no formato JSON:

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

   PowerShell

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

   Se a solicitação for bem-sucedida, o servidor retornará a resposta no formato JSON:

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

Como testar o roteamento de mensagens

Para testar o roteamento de mensagens, conclua as etapas nas seções a seguir.

Como configurar e iniciar o primeiro receptor e adaptador

Para configurar e iniciar o primeiro receptor e adaptador, siga estas etapas:

1. Na máquina em que você extraiu a imagem do Docker pré-criada, execute o seguinte comando para instalar o Netcat:

   sudo apt install netcat
   

2. Faça o download de hl7v2-mllp-ack-sample.txt, caso ainda não tenha feito isso. O arquivo contém uma mensagem ACK usada como resposta pelo adaptador quando tenta publicar uma mensagem.

3. Para definir a porta 2525 para o primeiro receptor, execute o seguinte comando:

   Linux

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

   Quando o processo do Netcat é iniciado, a seguinte saída é exibida:

   listening on [any] 2525 ...
   

4. Para iniciar o primeiro adaptador, em um novo terminal, execute o seguinte 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

   onde:

   • PROJECT_ID é o código do projeto do Google Cloud que contém o armazenamento HL7v2.
   • LOCATION é a região em que sua loja HL7v2 está localizada;
   • DATASET_ID é o código do conjunto de dados pai do armazenamento HL7v2.
   • HL7V2_STORE_ID é o código do armazenamento HL7v2 para o qual você está enviando mensagens HL7v2.
   • PROJECT_ID é o código do projeto do Google Cloud que contém o tópico do Pub/Sub.
   • PUBSUB_SUBSCRIPTION é o nome da primeira assinatura que você criou associada ao primeiro tópico do Pub/Sub. O adaptador consome mensagens dessa assinatura e as reconhece automaticamente.

   Depois de executar esse comando, o adaptador começa a ser executado na máquina local em 127.0.0.1:2575. Ele publica novas mensagens no primeiro receptor externo na porta 2525.

Como configurar e iniciar o segundo receptor e adaptador

Para configurar e iniciar o segundo receptor e adaptador, siga estas etapas:

1. Na máquina em que você extraiu a imagem do Docker pré-criada, execute o seguinte comando para instalar o Netcat:

   sudo apt install netcat
   

2. Faça o download de hl7v2-mllp-ack-sample.txt, caso ainda não tenha feito isso. O arquivo contém uma mensagem ACK usada como resposta pelo adaptador quando tenta publicar uma mensagem.

3. Para definir a porta 2526 para o segundo receptor, execute o seguinte comando.

   Linux

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

   Quando o processo do Netcat é iniciado, a seguinte saída é exibida:

   listening on [any] 2526 ...
   

4. Para iniciar o segundo adaptador, em um novo terminal, execute o seguinte comando:

   docker run \
       --network=host \
       gcr.io/cloud-healthcare-containers/mllp-adapter \
       /usr/mllp_adapter/mllp_adapter \
       --hl7_v2_project_id=PROJECT_ID \
       --hl7_v2_location_id=LOCATION \
       --hl7_v2_dataset_id=DATASET_ID \
       --hl7_v2_store_id=HL7V2_STORE_ID \
       --export_stats=false \
       --receiver_ip=127.0.0.1 --port 2576 \
       --mllp_addr=127.0.0.1:2526 \
       --pubsub_project_id=PROJECT_ID \
       --pubsub_subscription=SECOND_PUBSUB_SUBSCRIPTION \
       --api_addr_prefix=https://healthcare.googleapis.com:443/v1 \
       --logtostderr

   onde:

   • PROJECT_ID é o código do projeto do Google Cloud que contém o armazenamento HL7v2.
   • LOCATION é a região em que sua loja HL7v2 está localizada;
   • DATASET_ID é o código do conjunto de dados pai do armazenamento HL7v2.
   • HL7V2_STORE_ID é o código do armazenamento HL7v2 para o qual você está enviando mensagens HL7v2.
   • PROJECT_ID é o código do projeto do Google Cloud que contém o tópico do Pub/Sub.
   • SECOND_PUBSUB_SUBSCRIPTION é o nome da segunda assinatura que você criou associada ao segundo tópico do Pub/Sub. O adaptador consome mensagens dessa assinatura e as reconhece automaticamente.

   Depois de executar esse comando, o adaptador começa a ser executado na máquina local na porta 127.0.0.1:2576. Ele publica novas mensagens no segundo receptor externo na porta 2526.

Como publicar uma mensagem no primeiro destinatário

Para criar uma mensagem que será publicada apenas no primeiro receptor externo, siga estas etapas:

1. Download hl7v2-sample1.json.

2. No diretório em que você fez o download de hl7v2-sample1.json, chame o método messages.create para criar a mensagem em um armazenamento HL7v2:

   curl

   Para criar uma mensagem HL7v2, faça uma solicitação POST e especifique as seguintes informações:

   • O nome do conjunto de dados pai
   • O nome do armazenamento HL7v2
   • Uma mensagem
   • Um token de acesso

   O exemplo a seguir mostra uma solicitação POST usando curl e um arquivo JSON de exemplo, hl7v2-sample1.json.

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

   Se a solicitação for bem-sucedida, o servidor retornará a resposta no formato JSON:

   {
    "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
    "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZXzF8QXxBfDIwMTgwMTAxMDAwMDAwfHxUWVBFXkF8MjAxODAxMDEwMDAwMDB8VHwwLjB8fHxBQXx8MDB8QVNDSUkNRVZOfEEwMHwyMDE4MDEwMTA0MDAwMA1QSUR8fDE0ATExMV5eXl5NUk58MTExMTExMTFeXl5eTVJOfjExMTExMTExMTFeXl5eT1JHTk1CUg==",
    "sendFacility": "SEND_FACILITY_1",
    "sendTime": "2018-01-01T00:00:00Z",
    "messageType": "TYPE",
    "createTime": "1970-01-01T00:00:00Z",
    "patientIds": [
      {
        "value": "14\u0001111",
        "type": "MRN"
      },
      {
        "value": "11111111",
        "type": "MRN"
      },
      {
        "value": "1111111111",
        "type": "ORGNMBR"
      }
    ]
   }
   

   PowerShell

   Para criar uma mensagem HL7v2, faça uma solicitação POST e especifique as seguintes informações:

   • O nome do conjunto de dados pai
   • O nome do armazenamento HL7v2
   • Uma mensagem
   • Um token de acesso

   O exemplo a seguir mostra uma solicitação POST usando o Windows PowerShell e um arquivo JSON de exemplo chamado hl7v2-sample1.json.

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

   Se a solicitação for bem-sucedida, o servidor retornará a resposta no formato JSON:

   {
    "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
    "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZXzF8QXxBfDIwMTgwMTAxMDAwMDAwfHxUWVBFXkF8MjAxODAxMDEwMDAwMDB8VHwwLjB8fHxBQXx8MDB8QVNDSUkNRVZOfEEwMHwyMDE4MDEwMTA0MDAwMA1QSUR8fDE0ATExMV5eXl5NUk58MTExMTExMTFeXl5eTVJOfjExMTExMTExMTFeXl5eT1JHTk1CUg==",
    "sendFacility": "SEND_FACILITY_1",
    "sendTime": "2018-01-01T00:00:00Z",
    "messageType": "TYPE",
    "createTime": "1970-01-01T00:00:00Z",
    "patientIds": [
      {
        "value": "14\u0001111",
        "type": "MRN"
      },
      {
        "value": "11111111",
        "type": "MRN"
      },
      {
        "value": "1111111111",
        "type": "ORGNMBR"
      }
    ]
   }
   

   Nesta resposta, sendFacility é definido como SEND_FACILITY_1. Portanto, a notificação do Pub/Sub é enviada apenas para o primeiro tópico do Pub/Sub. Depois de criar a mensagem, o primeiro adaptador MLLP retorna a seguinte resposta:

   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.
   

   O segundo adaptador MLLP não retorna nenhuma resposta porque nenhuma notificação é enviada para o segundo tópico do Pub/Sub.

   No terminal em que você executou o primeiro processo do Netcat, a saída a seguir é exibida. Essa saída indica que a mensagem foi publicada.

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

   Essa saída corresponde ao valor no campo data da resposta recebida quando você criou a mensagem. É o mesmo que o valor data no arquivo hl7v2-sample1.json.

Como publicar uma mensagem no segundo destinatário

Para criar uma mensagem que só será publicada no segundo receptor externo, siga estas etapas:

1. Abra um novo terminal na máquina local.

2. Para criar uma mensagem que será publicada apenas no segundo receptor externo, faça o download de hl7v2-sample2.json.

3. No diretório em que você fez o download de hl7v2-sample2.json, chame o método messages.create para criar a mensagem em um armazenamento HL7v2:

   curl

   Para criar uma mensagem HL7v2, faça uma solicitação POST e especifique as seguintes informações:

   • O nome do conjunto de dados pai
   • O nome do armazenamento HL7v2
   • Uma mensagem
   • Um token de acesso

   O exemplo a seguir mostra uma solicitação POST usando curl e um arquivo JSON de exemplo, hl7v2-sample2.json.

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

   Se a solicitação for bem-sucedida, o servidor retornará a resposta no formato JSON:

   {
    "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
    "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZXzJ8QXxBfDIwMTgwMTAxMDAwMDAwfHxUWVBFXkF8MjAxODAxMDEwMDAwMDB8VHwwLjB8fHxBQXx8MDB8QVNDSUkNRVZOfEEwMHwyMDE4MDEwMTA0MDAwMA1QSUR8fDE0ATExMV5eXl5NUk58MTExMTExMTFeXl5eTVJOfjExMTExMTExMTFeXl5eT1JHTk1CUg==",
    "sendFacility": "SEND_FACILITY_2",
    "sendTime": "2018-01-01T00:00:00Z",
    "messageType": "TYPE",
    "createTime": "1970-01-01T00:00:00Z",
    "patientIds": [
      {
        "value": "14\u0001111",
        "type": "MRN"
      },
      {
        "value": "11111111",
        "type": "MRN"
      },
      {
        "value": "1111111111",
        "type": "ORGNMBR"
      }
    ]
   }
   

   PowerShell

   Para criar uma mensagem HL7v2, faça uma solicitação POST e especifique as seguintes informações:

   • O nome do conjunto de dados pai
   • O nome do armazenamento HL7v2
   • Uma mensagem
   • Um token de acesso

   O exemplo a seguir mostra uma solicitação POST usando o Windows PowerShell e um arquivo JSON de exemplo, hl7v2-sample2.json.

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

   Se a solicitação for bem-sucedida, o servidor retornará a resposta no formato JSON:

   {
    "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
    "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZXzJ8QXxBfDIwMTgwMTAxMDAwMDAwfHxUWVBFXkF8MjAxODAxMDEwMDAwMDB8VHwwLjB8fHxBQXx8MDB8QVNDSUkNRVZOfEEwMHwyMDE4MDEwMTA0MDAwMA1QSUR8fDE0ATExMV5eXl5NUk58MTExMTExMTFeXl5eTVJOfjExMTExMTExMTFeXl5eT1JHTk1CUg==",
    "sendFacility": "SEND_FACILITY_2",
    "sendTime": "2018-01-01T00:00:00Z",
    "messageType": "TYPE",
    "createTime": "1970-01-01T00:00:00Z",
    "patientIds": [
      {
        "value": "14\u0001111",
        "type": "MRN"
      },
      {
        "value": "11111111",
        "type": "MRN"
      },
      {
        "value": "1111111111",
        "type": "ORGNMBR"
      }
    ]
   }
   

   Observe que o sendFacility é SEND_FACILITY_2. Portanto, a notificação do Pub/Sub é enviada apenas para o segundo tópico do Pub/Sub. Depois de criar a mensagem, o primeiro adaptador MLLP não retorna nenhuma resposta, enquanto o segundo adaptador MLLP retorna a seguinte resposta:

   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.
   

   No terminal em que você executou o segundo processo do Netcat, a saída a seguir é exibida. Essa saída indica que a mensagem foi publicada.

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

   Essa saída corresponde ao valor no campo data da resposta recebida quando você criou a mensagem. É o mesmo que o valor data no arquivo hl7v2-sample2.json.

Como implantar o adaptador MLLP no Google Kubernetes Engine

Ao transmitir mensagens HL7v2 pela MLLP do seu centro de atendimento, uma configuração possível é enviar as mensagens para um adaptador implantado no Google Cloud e encaminhá-las para a API Cloud Healthcare.

O adaptador MLLP é executado como um aplicativo sem estado em um cluster do GKE. Um cluster do GKE é um grupo gerenciado de instâncias de VM para executar aplicativos em contêineres. Os aplicativos sem estado são aqueles que não armazenam dados ou estado do aplicativo no cluster ou no armazenamento permanente. Em vez disso, os dados e o estado do aplicativo permanecem no cliente, o que torna os aplicativos sem estado mais escalonáveis.

O GKE usa o Implantação para implantar aplicativos sem estado de forma uniforme e não exclusiva Pods. As implantações gerenciam o estado pretendido do aplicativo: quantos pods executarão seu aplicativo, qual versão da imagem do container será executada, como os pods serão rotulados e assim por diante. O estado desejado pode ser mudou dinamicamente por meio de atualizações Especificação do pod (em inglês).

Ao implantar o adaptador, você cria um controlador de serviço que permite conectar o adaptador à API Cloud Healthcare usando o balanceamento de carga interno.

Se você é novo no GKE, conclua o guia de início rápido do GKE para saber como o produto funciona.

Como adicionar permissões da API Pub/Sub à conta de serviço do GKE

Conforme especificado na documentação do GKE sobre Como autenticar no Cloud Platform com contas de serviço, cada nó em um cluster de contêiner é uma instância do Compute Engine. Portanto, quando o adaptador MLLP é executado em um cluster de contêiner, ele herda automaticamente os escopos das instâncias do Compute Engine em que é implantado.

O Google Cloud cria automaticamente uma conta de serviço chamada "Conta de serviço padrão do Compute Engine", e o GKE associa essa conta de serviço aos nós criados pelo GKE. Dependendo de como o projeto está configurado, a conta de serviço padrão pode ou não ter permissões para usar outras APIs do Cloud Platform. O GKE também atribui alguns escopos de acesso limitado às instâncias do Compute Engine.

Para melhores resultados, não faça a autenticação em outros serviços do Google Cloud (como o Pub/Sub) a partir de pods em execução no GKE atualizando as permissões da conta de serviço padrão ou atribuindo mais escopos de acesso às instâncias do Compute Engine. Em vez disso, crie suas próprias contas de serviço.

Você precisa conceder as permissões necessárias do Pub/Sub ao cluster de contêiner, mas também tem a opção de conceder permissões para gravar métricas no Cloud Monitoring.

Para criar uma nova conta de serviço que contenha apenas os escopos exigidos pelo cluster de contêiner, siga estas etapas:

Como criar o cluster

Para criar o cluster no GKE, execute o comando gcloud container clusters create:

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

onde:

• COMPUTE_ZONE é a zona em que o cluster está implantado. Uma zona é um local regional aproximado em que seus clusters e os respectivos recursos residem. Por exemplo, us-west1-a é uma zona na região us-west. Se você definiu uma zona padrão usando gcloud config set compute/zone, o valor dessa sinalização substitui o padrão.
• CLIENT_EMAIL é o identificador da conta de serviço que você quer usar. Ele usa o formato SERVICE_ACCOUNT_NAME@PROJECT_ID,iam.gserviceaccount.com.

O comando retorna uma saída semelhante à seguinte amostra:

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

Depois de criar o cluster, o GKE cria três instâncias de VM do Compute Engine. Para verificar isso, liste as instâncias com o seguinte comando:

gcloud compute instances list

Como configurar a implantação

Ao implantar um aplicativo no GKE, você define as propriedades da implantação usando um arquivo de manifesto de implantação, que normalmente é um arquivo YAML. Para ver uma amostra, consulte Como criar uma implantação.

1. Abra um terminal separado.

2. Usando um editor de texto, crie um arquivo de manifesto de implantação chamado mllp_adapter.yaml com o seguinte conteúdo:

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

onde:

• PROJECT_ID é o código do projeto do Google Cloud que contém o armazenamento HL7v2.
• LOCATION é a região em que sua loja HL7v2 está localizada;
• DATASET_ID é o código do conjunto de dados pai do armazenamento HL7v2.
• HL7V2_STORE_ID é o código do armazenamento HL7v2 para o qual você está enviando mensagens HL7v2.

A implantação tem as seguintes propriedades:

• spec: replicas: é o número de pods replicados que a implantação gerencia;
• spec: template: metadata: labels: é o rótulo dado a cada pod que a implantação usa para gerenciá-los;
• spec: template: spec: é o Especificação do pod que define como cada pod deve ser executado.
• spec: containers inclui o nome do contêiner a ser executado em cada pod e a imagem do contêiner que será executada.

Para mais informações sobre a especificação de implantação, consulte a referência da Deployment API.

Como configurar o serviço

Para tornar o adaptador MLLP acessível a aplicativos fora do cluster (como um centro de atendimento), configure um balanceador de carga interno.

Se você não tiver configurado uma VPN, os aplicativos poderão acessar o adaptador MLLP por meio do balanceador de carga interno, desde que os aplicativos usem a mesma rede VPC e estejam localizados na mesma região do Google Cloud. Por exemplo, para tornar o adaptador acessível a uma instância de VM do Compute Engine na mesma região e na mesma rede VPC, adicione um balanceador de carga interno ao Service do cluster. recurso.

No diretório em que você criou o arquivo de manifesto de implantação, use o editor de texto para criar um arquivo de manifesto de serviço chamado mllp_adapter_service.yaml com o conteúdo a seguir. Este arquivo é responsável por configurar o balanceamento de carga 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

O serviço tem as seguintes propriedades:

• metadata: name: é o nome escolhido para o serviço; Nesse caso, é mllp-adapter-service.
• metadata: annotations: é uma anotação que especifica que um balanceador de carga interno deve ser configurado.
• spec: type: é o tipo de balanceador de carga.
• ports: port: é usado para especificar a porta em que o serviço pode receber tráfego de outros serviços no mesmo cluster. A porta MLLP padrão de 2575 é usada.
• ports: targetPort: é usado para especificar a porta em cada pod em que o serviço está em execução.
• spec: selector: app: especifica os pods que o serviço segmenta.

Embora seja possível especificar um endereço IP para o balanceador de carga (usando o campo clusterIP), o balanceador de carga pode gerar seu próprio endereço IP para o qual você pode enviar mensagens. Por enquanto, permita que o cluster gere o endereço IP, que você vai usar mais adiante neste tutorial.

Para mais informações sobre balanceamento de carga interno, consulte a documentação do GKE.

Para mais informações sobre a especificação de serviço, consulte a Referência da API de serviço.

Como implantar a implantação

Para implantar o adaptador em um cluster do GKE, execute o seguinte comando no diretório que contém o arquivo de manifesto de implantação mllp_adapter.yaml:

kubectl apply -f mllp_adapter.yaml

O comando retorna a seguinte saída:

deployment.extensions "mllp-adapter-deployment" created

Como inspecionar a implantação

Depois de criar a implantação, use a ferramenta kubectl para inspecioná-la.

Para ver informações detalhadas sobre a implantação, execute o seguinte comando:

kubectl describe deployment mllp-adapter

Para listar o pod criado pela implantação, execute o seguinte comando:

kubectl get pods -l app=mllp-adapter

Para receber informações sobre o pod criado:

kubectl describe pod POD_NAME

Se a implantação tiver sido bem-sucedida, a última parte da saída do comando anterior deverá conter as seguintes informações:

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

Como implantar o serviço e criar o balanceador de carga interno

Para criar o balanceador de carga interno, execute o seguinte comando no diretório que contém o arquivo de manifesto de serviço mllp_adapter_service.yaml:

kubectl apply -f mllp_adapter_service.yaml

O comando retorna a seguinte saída:

service "mllp-adapter-service" created

Como inspecionar o serviço

Depois de criar o serviço, inspecione-o para verificar se ele foi configurado.

Para inspecionar o balanceador de carga interno, execute o seguinte comando:

kubectl describe service mllp-adapter-service

A saída do comando é semelhante à seguinte amostra:

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

O endereço IP LoadBalancer Ingress pode levar até um minuto para ser preenchido. Você usará esse endereço IP e a porta 2575 para acessar o serviço de fora do cluster na próxima etapa.

Como criar uma VM do Compute Engine e enviar mensagens

No início deste tutorial, você testou o adaptador MLLP localmente e enviou mensagens HL7v2 para seu armazenamento HL7v2, agora enviará mensagens de uma VM do Compute Engine para o adaptador MLLP em execução no GKE. As mensagens são encaminhadas para um armazenamento HL7v2.

Para enviar solicitações da nova instância para o cluster do GKE, a instância e as instâncias atuais precisam estar na mesma região e usar a mesma rede VPC.

No final desta seção, você listará as notificações publicadas no tópico do Pub/Sub e as mensagens HL7v2 na sua loja HL7v2. A instância de VM do Compute Engine precisa ter permissões para executar essas tarefas. Antes de criar a instância, crie uma nova conta de serviço com as permissões necessárias seguindo estas etapas:

As etapas a seguir mostram como criar uma instância de máquina virtual Linux no Compute Engine:

gcloud compute instances create COMPUTE_NAME \
   --project=PROJECT_ID \
   --zone=ZONE \
   --image-family=debian-10 \
   --image-project=debian-cloud \
   --tags=http-server \
   --service-account=SERVICE_ACCOUNT

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

Aguarde a inicialização da instância. Depois que a instância é iniciada, ela é listada na página "Instâncias de VMs" com um ícone de status verde.

Por padrão, a instância usa a mesma rede VPC padrão usada pelo cluster, o que significa que o tráfego pode ser enviado da instância para o cluster.

Para se conectar à instância, siga estas etapas:

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

Agora você tem uma janela de terminal para interagir com a instância do Linux.

1. Na janela do terminal, instale o Netcat:

   sudo apt install netcat
   

2. Faça o download do arquivo hl7v2-mllp-sample.txt e salve-o na instância. Para informações sobre a codificação e os terminadores de segmento usados no arquivo, consulte Separadores e segmentos de mensagens HL7v2.

3. Para começar a enviar mensagens HL7v2 por meio do adaptador MLLP para seu armazenamento HL7v2, execute o comando a seguir no diretório em que você fez o download. Use o valor de LoadBalancer Ingress exibido quando você inspecionou o serviço.

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

   Depois de executar o comando, a mensagem é enviada pelo adaptador MLLP para seu armazenamento HL7v2. Se a mensagem tiver sido processada com sucesso no armazenamento HL7v2, o comando retornará a seguinte saída:

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

   Essa saída indica que o armazenamento HL7v2 respondeu com um tipo de resposta AA (Application Accept), o que significa que a mensagem foi validada e processada.

4. Para ver a mensagem publicada no tópico do Pub/Sub, execute o comando gcloud pubsub subscriptions pull:

   gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION

   O comando retorna a seguinte saída sobre a mensagem HL7v2 ingerida:

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

5. Você também pode listar as mensagens no seu armazenamento HL7v2 para ver se a mensagem foi adicionada:

   curl

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

   Se a solicitação for bem-sucedida, o servidor retornará o código da mensagem em um caminho de 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

   Se a solicitação for bem-sucedida, o servidor retornará o código da mensagem em um caminho de recurso:

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

Depois de concluir esta seção, você implantou o adaptador MLLP no GKE e enviou uma mensagem HL7v2 de uma instância remota por meio do adaptador e para a API Cloud Healthcare.

No restante deste tutorial, você aprenderá a criptografar com segurança as mensagens HL7v2 transmitidas configurando uma VPN entre uma instância do Compute Engine, que atua como uma instância "local" e o adaptador.

Como configurar uma VPN

O uso de uma VPN permite estender a rede privada na qual você envia mensagens HL7v2 por meio de uma rede pública, como a Internet. Ao usar uma VPN, você pode enviar mensagens da sua central de atendimento por meio do adaptador MLLP e para o Google Cloud. Os sistemas nesse fluxo agem como se estivessem em uma única rede privada.

Há dois métodos para proteger sua conexão MLLP usando VPN:

• Como usar o Cloud VPN
• Como usar a solução de VPN de ponta a ponta forte

Como configurar o Cloud VPN

O Cloud VPN conecta sua rede local à rede nuvem privada virtual (VPC) do Google Cloud com segurança por meio de uma conexão VPN IPsec. O tráfego entre as duas redes é criptografado por um gateway de VPN e depois descriptografado por outro. Isso protege seus dados à medida que eles trafegam pela Internet ou por uma rede de atendimento.

Neste tutorial, cada gateway de VPN configurado está localizado em uma rede e sub-rede personalizada diferente em uma região diferente do Google Cloud.

O gateway da VPN configurado em us-central1 atua como o gateway do Cloud VPN no lado do Google Cloud, enquanto o gateway do Cloud VPN em europe-west1 simula o gateway "local".

Referência de nomenclatura e endereçamento

Para referência, este tutorial usa os seguintes nomes e endereços IP:

No lado do Google Cloud

• Nome da rede: cloud-vpn-network
• Nome da sub-rede: subnet-us-central-10-0-1
• Região: us-central1
• Intervalo da sub-rede: 10.0.1.0/24
• Nome do endereço IP externo: cloud-vpn-ip
• Nome do gateway de VPN: vpn-us-central
• Nome do túnel da VPN: vpn-us-central-tunnel-1

Local

• Nome da rede: on-prem-vpn-network
• Nome da sub-rede: subnet-europe-west-10-0-2
• Região: europe-west1
• Intervalo da sub-rede: 10.0.2.0/24
• Nome do endereço IP externo: on-prem-vpn-ip
• Nome do gateway de VPN: vpn-europe-west
• Nome do túnel da VPN: vpn-europe-west-tunnel-1

Como criar redes e sub-redes VPC personalizadas

A primeira etapa na configuração do Cloud VPN é criar duas redes VPC. Uma rede chamada on-prem-vpn-network é configurada no ambiente "local" e executada em uma instância de VM do Compute Engine chamada on-prem-instance. A outra rede, chamada cloud-vpn-network, é o que o cluster do GKE que executa o adaptador MLLP usa. Você se conectará à VM on-prem-instance e enviará mensagens HL7v2 para o adaptador MLLP em execução na rede cloud-vpn-network por meio do balanceador de carga interno do adaptador MLLP.

Crie duas redes VPC personalizadas e suas sub-redes concluindo as seguintes etapas:

1. Para criar a primeira rede VPC, cloud-vpn-network, execute o seguinte comando:

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

2. Para criar a sub-rede subnet-us-central-10-0-1 para a rede cloud-vpn-network, execute o seguinte 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 criar a rede VPC on-prem-vpn-network, execute o seguinte comando:

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

4. Para criar a sub-rede subnet-europe-west-10-0-2 para a rede VPC on-prem-vpn-network, execute o seguinte 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

Como criar um endereço IP externo

Antes de criar os gateways da VPN, reserve um endereço IP externo para cada gateway concluindo as seguintes etapas:

1. Para reservar um endereço IP externo estático (regional) para o endereço cloud-vpn-ip, execute o seguinte comando:

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

2. Para reservar um endereço IP externo estático (regional) para o endereço on-prem-vpn-ip, execute o seguinte comando:

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

3. Anote os endereços IP externos para que você possa usá-los para configurar os gateways da VPN na próxima seção. Para recuperar os endereços IP externos, execute o seguinte comando:

   Endereço IP do Cloud VPN:

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

   Endereço IP da VPN "local":

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

   Os comandos retornam uma saída semelhante a esta:

   address: 203.0.113.1
   

Como criar gateways, túneis e rotas de VPN

Conclua as etapas a seguir para criar o gateway, o túnel e a rota da VPN do Cloud VPN:

1. Crie uma chave pré-compartilhada criptograficamente forte (chave secreta compartilhada) seguindo as instruções em Como gerar uma chave pré-compartilhada forte. Esta chave é mencionada como SHARED_SECRET nesta seção.

2. Para criar o objeto gateway da VPN de destino, execute o seguinte comando:

   gcloud compute target-vpn-gateways create vpn-us-central \
      --project PROJECT_ID \
      --region us-central1 \
      --network cloud-vpn-network

3. Para criar três regras de encaminhamento, execute os seguintes comandos, substituindo a variável CLOUD_VPN_EXTERNAL_ADDRESS pelo valor do endereço IP do Cloud VPN na seção anterior:

   Envie o tráfego ESP (IPsec) para o gateway:

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

   Envie o tráfego UDP 500 para o gateway:

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

   Envie o tráfego UDP 4500 para o gateway:

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

4. Para criar um túnel no gateway do Cloud VPN, execute o comando a seguir. Substitua ON_PREM_VPN_IP pelo valor do endereço IP da VPN"local" na seção 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. Para criar uma rota estática para 10.0.2.0/24, execute o seguinte 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"

Conclua as etapas a seguir para criar o gateway, o túnel e a rota da VPN para a VPN "local":

1. Para criar o objeto gateway da VPN de destino, execute o seguinte comando:

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

2. Para criar três regras de encaminhamento, execute os seguintes comandos, substituindo a variável ON_PREMISES_VPN_EXTERNAL_ADDRESS pelo valor do endereço IP da VPN"local" na seção anterior:

   Envie o tráfego ESP (IPsec) para o gateway:

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

   Envie o tráfego UDP 500 para o gateway:

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

   Envie o tráfego UDP 4500 para o gateway:

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

3. Para criar um túnel no gateway "local", execute o seguinte 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. Para criar uma rota estática para 10.0.1.0/24, execute o seguinte 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"

Você criou os gateways do Cloud VPN e "no local" e iniciou os túneis deles. Os gateways da VPN não se conectarão até que você crie regras de firewall para permitir o tráfego pelo túnel entre elas.

Criar regras de firewall

É preciso criar regras de firewall para os dois lados do túnel da VPN. Essas regras permitem que todo o tráfego TCP, UDP e ICMP entre na sub-rede de um lado do túnel da VPN para o outro.

1. Para criar as regras de firewall para a sub-rede do Cloud VPN, execute o seguinte 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 criar as regras de firewall para a sub-rede "local", execute o seguinte 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. Crie uma regra de firewall que permita o SSH na instância de VM na porta 22 executando o seguinte 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

Como verificar o status do túnel VPN

Para verificar se o túnel está ativo, siga estas etapas:

1. Acesse a página VPN no Console do Google Cloud.

   Acesse a página VPN

2. Clique na guia Túneis VPN do Google.

3. No campo Status de cada túnel, procure uma marca de seleção verde e a palavra "Estabelecido". Se esses itens estiverem lá, seus gateways negociaram um túnel. Se não aparecer nenhuma marca em alguns minutos, consulte a Solução de problemas.

   Para mais informações sobre a geração de registros relacionadas aos túneis da VPN, consulte Como verificar os registros de VPN na página Solução de problemas. Por exemplo, é possível ver métricas sobre pacotes descartados, status de túneis, bytes recebidos e bytes enviados.

Agora que você configurou o Cloud VPN com os gateways, túneis e regras de firewall necessários, crie uma conexão segura entre a instância de VM "local" e o adaptador MLLP em execução no GKE.

Como combinar a implantação no GKE e no Cloud VPN

Antes, neste tutorial, você testou o adaptador MLLP localmente e enviou mensagens HL7v2 por meio de uma conexão não VPN ao adaptador MLLP, agora enviará mensagens de um Compute Engine VM por meio de uma conexão segura usando o Cloud VPN com o adaptador MLLP em execução no GKE. As mensagens são encaminhadas para um armazenamento HL7v2.

Como recriar a implantação

Primeiro, recrie a implantação no GKE para que o cluster use as configurações definidas em Como configurar o Cloud VPN:

1. Para excluir o cluster mllp-adapter que você criou, execute o comando gcloud container clusters delete. Digite o valor COMPUTE_ZONE que você usou quando criou o cluster.

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

2. Siga as etapas em Como implantar o adaptador MLLP no Kubernetes Engine, mas ao criar o cluster no GKE, adicione a rede cloud-vpn-network e a sub-rede subnet-us-central-10-0-1 que criado em Como criar redes e sub-redes VPN personalizadas.

   Verifique se o comando de criação do cluster é semelhante ao seguinte:

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

   onde:

   • COMPUTE_ZONE é a zona em que o cluster está implantado. Ao configurar o Cloud VPN na seção anterior, você definiu a rede "do lado do Google Cloud" para usar us-central1. Esse "lado do Google Cloud" rede é o que a o cluster do GKE é executado. Use qualquer uma das seguintes zonas em us-central1: us-central1-c, us-central1-a, us-central1-f, us-central1-b.

   • CLIENT_EMAIL é o identificador da conta de serviço que você quer usar. Ele usa o formato SERVICE_ACCOUNT_NAME@PROJECT_ID,iam.gserviceaccount.com.

Como criar uma nova VM do Compute Engine com configurações de rede

As etapas a seguir mostram como criar uma instância de máquina virtual do Linux no Compute Engine usando o console do Google Cloud. Ao contrário da VM do Compute Engine que você criou, essa VM usa as configurações de rede "no local" para se comunicar com o cluster do GKE por meio de uma VPN.

gcloud compute instances create COMPUTE_NAME \
   --project=PROJECT_ID
   --zone=ZONE
   --image-family=debian-10 \
   --tags=http-server,https-server
   --service-account=SERVICE_ACCOUNT

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 se conectar à instância, siga estas etapas:

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

Agora você tem uma janela de terminal para interagir com a instância do Linux.

1. Na janela do terminal, instale o Netcat:

   sudo apt install netcat
   

2. Faça o download do arquivo hl7v2-mllp-sample.txt e salve-o na instância.

3. Para começar a enviar mensagens HL7v2 por meio do adaptador MLLP para seu armazenamento HL7v2, execute o comando a seguir no diretório em que você fez o download. Use o valor de LoadBalancer Ingress exibido quando você inspecionou o serviço.

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

   Depois de executar o comando, a mensagem é enviada pelo adaptador MLLP para seu armazenamento HL7v2. Se a mensagem tiver sido processada com sucesso no armazenamento HL7v2, o comando retornará a seguinte saída:

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

   Essa saída indica que o armazenamento HL7v2 respondeu com um tipo de resposta AA (Application Accept), o que significa que a mensagem foi validada e processada.

4. Para ver a mensagem publicada no tópico do Pub/Sub, execute o comando gcloud pubsub subscriptions pull:

   gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION

   O comando retorna a seguinte saída sobre a mensagem HL7v2 ingerida:

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

5. Você também pode listar as mensagens no seu armazenamento HL7v2 para ver se a mensagem foi adicionada:

   curl

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

   Se a solicitação for bem-sucedida, o servidor retornará o código da mensagem em um caminho de 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

   Se a solicitação for bem-sucedida, o servidor retornará o código da mensagem em um caminho de recurso:

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

Depois de concluir esta seção, você implantou o adaptador MLLP no GKE e, com uma VPN, enviou com segurança uma mensagem HL7v2 de uma instância "local" por meio do adaptador e para a API Cloud Healthcare.

Limpar

É possível limpar os recursos que foram criados no Google Cloud para evitar cobranças na conta do Google Cloud pelos recursos usados neste tutorial.

Exclua o projeto

Siga as etapas abaixo para excluir o projeto criado neste tutorial:

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

   Go to Manage resources

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

Resolver problemas

Falhas no adaptador

Depois de implantar o adaptador MLLP no GKE, o adaptador encontra uma falha.

• Siga as etapas em Solução de problemas com cargas de trabalho implantadas.

Erro Connection refused ao executar localmente

Ao testar o adaptador MLLP localmente, você encontra o erro Connection refused.

• Esse erro ocorre com alguns usuários do Mac OS. Em vez de usar a sinalização --network=host, use -p 2575:2575. Além disso, em vez de definir --receiver_ip=127.0.0.0, defina --receiver_ip=0.0.0.0. O comando deve ter esta aparência:

  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

Erro could not find default credentials ao executar localmente

Ao testar o adaptador MLLP localmente, você encontrar o erro healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials.

Esse erro ocorre quando o adaptador não consegue encontrar o Credenciais do ADC. Verifique se você configurou o Application Default Credentials no seu ambiente local.

Erros de autenticação

Se você encontrar erros de autenticação ao testar o adaptador MLLP localmente que não foram abordados no restante desta seção, execute o comando docker run novamente e adicione o -v ~/.config:/root/.config ao final do comando, assim:

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