Transmissão de mensagens HL7v2 através de ligações TCP/IP

Este tutorial fornece instruções para transmitir mensagens HL7v2 através de ligações TCP/IP usando o protocolo de camada inferior mínimo (MLLP). Para exigir que a imagem MLLP seja assinada por um atestador, siga os passos descritos no artigo Transmitir mensagens HL7v2 através de ligações TCP/IP com uma imagem MLLP assinada.

Este tutorial fornece instruções para executar o adaptador MLLP de código aberto alojado no GitHub nos seguintes ambientes:

• Localmente/no local.
• Num contentor no GKE com o Cloud VPN.
• Num contentor no GKE sem o Cloud VPN.

Objetivos

Depois de concluir este tutorial, vai saber como:

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

Custos

Neste documento, usa 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 custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Antes de começar

Antes de começar este tutorial, familiarize-se com a documentação conceptual sobre o protocolo de camada inferior mínimo (MLLP) revendo o MLLP e o Google Cloud adaptador MLLP. A documentação conceptual fornece uma vista geral do MLLP, como os sistemas de cuidados de saúde podem enviar e receber mensagens para e do Cloud Healthcare API através de uma ligação MLLP e os princípios básicos da segurança MLLP.

Antes de poder configurar o adaptador MLLP, tem de escolher ou criar um Google Cloud projeto e ativar as APIs necessárias através dos seguintes passos:

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.

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

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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

Go to project selector

Verify that billing is enabled for your Google Cloud project.

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

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

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

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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

Go to project selector

Verify that billing is enabled for your Google Cloud project.

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

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

1. Aguarde até que a API Kubernetes Engine e os serviços relacionados sejam ativados. Esta ação pode demorar vários minutos.

Escolher uma shell

Para concluir este tutorial, pode usar a Cloud Shell ou a shell local.

O Cloud Shell é um ambiente de shell para gerir recursos alojados no Google Cloud. O Cloud Shell é pré-instalado com a CLI gcloud e a ferramenta kubectl. A CLI gcloud fornece a interface de linhas de comando principal para Google Cloud. kubectl fornece a interface de linhas de comando para executar comandos em clusters do GKE.

Se preferir usar a shell local, tem de instalar a CLI gcloud.

Para abrir o Cloud Shell ou configurar o seu shell local, conclua os passos seguintes:

Cloud Shell

Para iniciar o Cloud Shell, conclua os seguintes passos:

1. Aceda à Google Cloud consola.

   Google Cloud consola

2. No canto superior direito da consola, clique no botão Ativar Google Cloud Shell:

É aberta uma sessão do Cloud Shell numa moldura na parte inferior da consola. Use este shell para executar comandos gcloud e kubectl.

Shell local

Para instalar a CLI gcloud e a ferramenta kubectl, conclua os seguintes passos:

1. Instale e inicialize a CLI Google Cloud.

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

   gcloud auth application-default login

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

   If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

3. Se estiver apenas a testar o adaptador localmente, não tem de concluir mais passos e pode continuar a criar um conjunto de dados. Se estiver a implementar o adaptador no GKE, instale a ferramenta de linha de comandos kubectl executando o seguinte comando:

   gcloud components install kubectl

Criar um conjunto de dados

Se ainda não criou um conjunto de dados da Cloud Healthcare API, crie um conjunto de dados concluindo os seguintes passos:

Consola

1. Na Google Cloud consola, aceda à página Conjuntos de dados.

   Aceda aos conjuntos de dados

2. Clique em Criar conjunto de dados.
3. No campo Nome, introduza um identificador para o conjunto de dados. O ID do conjunto de dados tem de ter o seguinte:
   • Um ID exclusivo na respetiva localização
   • Uma string Unicode de 1 a 256 carateres que consiste no seguinte:
     • Numbers
     • Cartas
     • Sublinhados
     • Traços
     • Períodos
4. Na secção Tipo de localização, escolha um dos seguintes tipos de localizações:
   • Região: o conjunto de dados reside permanentemente numa Google Cloud região. Depois de selecionar, escreva ou selecione a localização no campo Região.
   • Multirregional: o conjunto de dados reside permanentemente numa localização que abrange várias Google Cloud regiões. Depois de selecionar, escreva ou selecione a localização de várias regiões no campo de várias regiões.
5. Clique em Criar.

O novo conjunto de dados é apresentado na lista de conjuntos de dados.

gcloud

Para criar um conjunto de dados, execute o comando gcloud healthcare datasets create:

gcloud healthcare datasets create DATASET_ID \
    --location=LOCATION

Se o pedido for bem-sucedido, o comando devolve o seguinte resultado:

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

Criar um tópico e uma subscrição do Pub/Sub

Para receber notificações quando as mensagens são criadas ou carregadas, tem de configurar um tópico do Pub/Sub com a sua loja HL7v2. Para mais informações, consulte o artigo Configurar notificações do Pub/Sub.

Para criar um tópico, conclua os seguintes passos:

Consola

1. Aceda à página Tópicos do Pub/Sub na Google Cloud consola.

   Aceda à página de tópicos do Pub/Sub

2. Clique em Criar tópico.

3. Introduza um nome do tópico com o URI:

   projects/PROJECT_ID/topics/TOPIC_NAME

   onde PROJECT_ID é o ID do seu Google Cloud projeto.

4. Clique em Criar.

gcloud

Para criar um tópico, execute o comando gcloud pubsub topics create:

gcloud pubsub topics create projects/PROJECT_ID/topics/TOPIC_NAME

Se o pedido for bem-sucedido, o comando devolve o seguinte resultado:

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

Para criar uma subscrição, conclua os seguintes passos:

Consola

1. Aceda à página Tópicos do Pub/Sub na Google Cloud consola.

   Aceda à página de tópicos do Pub/Sub

2. Clique no tópico do seu projeto.

3. Clique em Criar subscrição.

4. Introduza um nome da subscrição:

   projects/PROJECT_ID/subscriptions/SUBSCRIPTION_NAME

5. Deixe o Tipo de fornecimento definido como Extrair e, de seguida, clique em Criar.

gcloud

Para criar uma subscrição, execute o comando gcloud pubsub subscriptions create:

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

Nota: para configurar o número de segundos que o sistema aguarda pela confirmação do subscritor antes de tentar novamente a entrega, use a flag opcional --ack-deadline. Sem este sinalizador, o prazo predefinido é de 10 segundos.

Se o pedido for bem-sucedido, o comando devolve o seguinte resultado:

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

Criar um armazenamento HL7v2 configurado com um tópico Pub/Sub

Crie um armazenamento HL7v2 e configure-o com um tópico Pub/Sub. Para criar um armazenamento de HL7v2, já tem de ter criado um conjunto de dados. Para os fins deste tutorial, use o mesmo projeto para a loja HL7v2 e para o tópico do Pub/Sub.

Para criar um armazenamento HL7v2 configurado com um tópico do Pub/Sub, conclua os seguintes passos:

curl

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

Nota: neste exemplo, filter não está definido para que a API Cloud Healthcare envie uma notificação do Pub/Sub para cada mensagem criada ou carregada.

Se o pedido for bem-sucedido, o servidor devolve 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"
    }
  ]
}

PowerShell

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

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

Nota: neste exemplo, filter não está definido para que a API Cloud Healthcare envie uma notificação do Pub/Sub para cada mensagem criada ou carregada.

Se o pedido for bem-sucedido, o servidor devolve 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"
    }
  ]
}

Configurar autorizações do Pub/Sub

Para enviar notificações para o Pub/Sub quando uma mensagem HL7v2 é criada ou carregada, tem de configurar as autorizações do Pub/Sub na Cloud Healthcare API. Tem de realizar este passo uma vez por projeto.

Para adicionar a função pubsub.publisher necessária à conta de serviço do seu projeto, conclua os seguintes passos:

Consola

1. Na página IAM na Google Cloud consola, verifique se a função Agente de serviço de cuidados de saúde aparece na coluna Função para a conta de serviço do projeto relevante. O nome da conta é [e-mail]. Para obter informações sobre como encontrar o PROJECT_NUMBER, consulte o artigo Identificar projetos.

2. Na coluna Herança que corresponde à função, clique no ícone de lápis. É aberto o painel Editar autorizações.

3. Clique em Adicionar outra função e, de seguida, pesquise a função Publicador do Pub/Sub.

4. Selecione a função e, de seguida, clique em Guardar. A função pubsub.publisher é adicionada à conta de serviço.

gcloud

Para adicionar as autorizações da conta de serviço, execute o comando gcloud projects add-iam-policy-binding. Para obter informações sobre como encontrar o PROJECT_ID e o PROJECT_NUMBER, consulte o artigo Identificar projetos.

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:[e-mail] \
    --role=roles/pubsub.publisher

Extrair a imagem do Docker pré-criada

O adaptador MLLP é uma aplicação contentorizada preparada numa imagem Docker pré-criada no Container Registry.

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

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

Testar o adaptador MLLP localmente

Quando testar o adaptador localmente, pode configurá-lo para ser executado como um recetor, um publicador ou ambos. As configurações do recetor e do publicador têm as seguintes diferenças principais:

• Quando o adaptador é executado como recetor, recebe mensagens HL7v2 de uma fonte externa e chama messages.ingest para carregar as mensagens num arquivo HL7v2, criando assim uma notificação do Pub/Sub. A notificação é enviada para as aplicações que subscreveram o tópico Pub/Sub da loja HL7v2.
• Quando o adaptador é executado como publicador, ouve mensagens HL7v2 que foram criadas ou carregadas numa loja HL7v2 através de messages.create ou messages.ingest. Depois de criar uma mensagem, é enviada uma notificação do Pub/Sub para o adaptador, e o adaptador publica as mensagens num recetor externo.

As secções seguintes mostram como executar o adaptador para que funcione como um recetor ou um editor.

Depois de verificar que pode executar o adaptador MLLP na sua máquina local, pode continuar para a secção seguinte sobre a Implementação do adaptador MLLP no Google Kubernetes Engine.

Testar o adaptador MLLP localmente como recetor

Quando o adaptador recebe uma mensagem HL7v2 de uma origem externa, como um centro de cuidados, o adaptador chama messages.ingest e carrega a mensagem HL7v2 para o arquivo HL7v2 configurado. Pode observar isto no código-fonte do adaptador.

Para testar o adaptador localmente como recetor, conclua os seguintes passos:

1. Na máquina onde extraiu a imagem de 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

   where:

   • PROJECT_ID é o ID do Google Cloud projeto que contém o seu armazenamento de HL7v2.
   • LOCATION é a região onde o seu armazenamento de HL7v2 está localizado.
   • DATASET_ID é o ID do conjunto de dados principal do seu armazenamento de HL7v2.
   • HL7V2_STORE_ID é o ID do armazenamento de HL7v2 para o qual está a enviar mensagens HL7v2.

   Depois de executar o comando anterior, o adaptador imprime uma mensagem semelhante à seguinte e começa a ser executado na sua máquina local no endereço IP 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 encontrar erros, siga estes passos de resolução de problemas:

   • Se estiver a usar o Mac OS e o comando anterior falhar com um erro Connection refused, consulte o artigo Erro de ligação recusada ao executar localmente.

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

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

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

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

   sudo apt install netcat
   

4. Transfira o ficheiro hl7v2-mllp-sample.txt e guarde-o no seu computador local.

5. Para enviar a mensagem HL7v2 para o adaptador, no diretório onde transferiu o ficheiro, execute o seguinte comando. O adaptador MLLP está a ouvir no seu anfitrião local na porta 2575. O comando envia a mensagem através do adaptador MLLP para o 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 carregada com êxito na loja HL7v2, o comando devolve o seguinte 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 o armazenamento HL7v2 respondeu com um tipo de resposta AA (Application Accept), o que significa que a mensagem foi validada e carregada com êxito.

6. Também pode verificar se a mensagem foi enviada com êxito abrindo o terminal onde executou o adaptador. O resultado deve ser semelhante ao seguinte exemplo:

    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 no seu armazenamento de HL7v2, para que possa 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 o pedido for bem-sucedido, o servidor devolve o ID da mensagem num 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 o pedido for bem-sucedido, o servidor devolve o ID da mensagem num caminho de recurso:

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

Testar o adaptador MLLP localmente como publicador

Quando testa o adaptador como publicador, cria mensagens chamando messages.create ou messages.ingest e fornecendo um ficheiro de mensagem como dados binários.

O adaptador confirma automaticamente as mensagens do Pub/Sub enviadas através do messages.create e do messages.ingest.

O adaptador envia-lhe uma notificação quando obtém e envia com êxito mensagens do Pub/Sub. O adaptador é um subscritor do Pub/Sub, pelo que reconhece automaticamente estas mensagens. Como resultado, são removidas da fila de mensagens na subscrição do Pub/Sub que configurou com o adaptador.

Para extrair da subscrição do Pub/Sub e verificar separadamente se as mensagens foram publicadas, tem de criar uma segunda subscrição do Pub/Sub atribuída ao tópico que criou anteriormente. As mensagens enviadas para a segunda subscrição não são reconhecidas automaticamente pelo adaptador e persistem para que as possa obter.

Para criar uma segunda subscrição do Pub/Sub atribuída ao tópico que criou anteriormente, conclua os seguintes passos:

Consola

1. Aceda à página Tópicos do Pub/Sub na Google Cloud consola.

   Aceda à página de tópicos do Pub/Sub

2. Clique no tópico do seu projeto. Este é o tópico que usou para criar a subscrição inicial.

3. Clique em Criar subscrição.

4. Introduza um nome da subscrição:

   projects/PROJECT_ID/subscriptions/SECOND_SUBSCRIPTION_NAME

   Deixe o Tipo de fornecimento definido como Extrair.

5. Clique em Criar.

gcloud

Para criar uma segunda subscrição do Pub/Sub atribuída ao tópico que criou anteriormente, execute o comando gcloud pubsub subscriptions create:

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

Nota: para configurar o número de segundos que o sistema aguarda pela confirmação do subscritor antes de tentar novamente a entrega, use a flag opcional --ack-deadline. Sem este sinalizador, o prazo predefinido é de 10 segundos.

Se o pedido for bem-sucedido, o comando devolve o seguinte resultado:

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

Para testar o adaptador localmente como publicador, conclua os seguintes passos na máquina onde extraiu a imagem Docker pré-criada:

1. Instale o Netcat:

   sudo apt install netcat
   

2. Transfira o ficheiro hl7v2-mllp-ack-sample.txt e guarde-o no seu computador local. O ficheiro contém uma mensagem ACK que o adaptador requer como resposta quando tenta publicar uma mensagem.

3. Para permitir que o Netcat ouça ligações recebidas na porta 2525, no diretório onde transferiu o ficheiro, execute o seguinte comando.

   Linux

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

   Depois de iniciar o Netcat, é apresentada uma mensagem de saída semelhante ao seguinte exemplo:

   listening on [any] 2525 ...
   

4. O Netcat é executado como um processo em primeiro plano. Por isso, para continuar com os testes, abra um terminal diferente na sua máquina local.

5. Para iniciar o adaptador, no 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

   where:

   • PROJECT_ID é o ID do Google Cloud projeto que contém o seu armazenamento de HL7v2.
   • LOCATION é a região onde o seu armazenamento de HL7v2 está localizado.
   • DATASET_ID é o ID do conjunto de dados principal do seu armazenamento de HL7v2.
   • HL7V2_STORE_ID é o ID do armazenamento de HL7v2 para o qual está a enviar mensagens HL7v2.
   • PROJECT_ID é o ID do projeto Google Cloud que contém o tópico do Pub/Sub.
   • PUBSUB_SUBSCRIPTION é o nome da primeira subscrição que criou associada ao seu tópico do Pub/Sub. O adaptador consome mensagens desta subscrição e confirma-as automaticamente, pelo que, para ver as mensagens publicadas no tópico, tem de extrair mensagens da segunda subscrição que criou anteriormente.

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

   Se encontrar erros, siga estes passos de resolução de problemas:

   • Se estiver a usar o Mac OS e o comando anterior falhar com um erro Connection refused, consulte o artigo Erro de ligação recusada ao executar localmente.

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

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

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

6. Transfira o ficheiro hl7v2-sample.json e guarde-o no seu computador local. No diretório onde transferiu o ficheiro, chame o método messages.create para criar a mensagem num armazenamento HL7v2:

   curl

   Para criar uma mensagem HL7v2, faça um pedido POST e especifique as seguintes informações:

   • O nome do conjunto de dados principal
   • O nome do armazenamento de HL7v2
   • Uma mensagem
   • Uma chave de acesso

   O exemplo seguinte mostra um pedido POST com curl e um exemplo de ficheiro JSON denominado 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 o pedido for bem-sucedido, o servidor devolve 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 um pedido POST e especifique as seguintes informações:

   • O nome do conjunto de dados principal
   • O nome do armazenamento de HL7v2
   • Uma mensagem
   • Uma chave de acesso

   O exemplo seguinte mostra um pedido POST através do Windows PowerShell e um ficheiro JSON de exemplo denominado 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 o pedido for bem-sucedido, o servidor devolve 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 devolve uma resposta semelhante à 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 onde executou o Netcat, é apresentado um resultado semelhante ao exemplo seguinte. Este resultado 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^\
   

   Isto corresponde ao valor no campo data da resposta que recebeu quando criou a mensagem. É o mesmo que o valor data no ficheiro 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 subscrição do Pub/Sub que criou:

   gcloud pubsub subscriptions pull --auto-ack SECOND_SUBSCRIPTION

   O comando devolve a seguinte saída sobre a mensagem HL7v2 criada. Tenha em atenção 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  |
   └-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘

Publicar mensagens em diferentes recetores externos

Pode configurar o arquivo HL7v2 com vários tópicos do Pub/Sub e usar filtros para enviar notificações para diferentes tópicos do Pub/Sub. Em seguida, pode executar um adaptador MLLP para cada tópico do Pub/Sub para publicar as mensagens num recetor externo diferente.

Importante: a publicação de mensagens para diferentes destinatários externos e o teste das mesmas requerem a abertura de cinco terminais. Uma vez que o número máximo de terminais abertos no Cloud Shell é quatro, tem de executar os passos nas secções seguintes num shell local.

Para configurar o armazenamento HL7v2 com vários tópicos do Pub/Sub e um filtro para cada tópico, conclua os seguintes passos:

1. Crie dois tópicos Pub/Sub e uma subscrição para cada tópico. Para mais informações, consulte o artigo Criar um tópico e uma subscrição do Pub/Sub.

2. Execute o seguinte 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 o pedido for bem-sucedido, o servidor devolve 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 o pedido for bem-sucedido, o servidor devolve 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\""
       }
     ]
   }
   

Testar o encaminhamento de mensagens

Para testar o encaminhamento de mensagens, conclua os passos nas secções seguintes.

Configurar e iniciar o primeiro recetor e transformador

Para configurar e iniciar o primeiro recetor e adaptador, conclua os seguintes passos:

1. Na máquina onde extraiu a imagem Docker pré-criada, execute o seguinte comando para instalar o Netcat:

   sudo apt install netcat
   

2. Transfira hl7v2-mllp-ack-sample.txt, se ainda não o tiver feito. O ficheiro contém uma mensagem ACK usada como resposta pelo adaptador quando tenta publicar uma mensagem.

3. Para definir a porta 2525 para o primeiro destinatário, 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 Netcat é iniciado, é apresentado o seguinte resultado:

   listening on [any] 2525 ...
   

4. Para iniciar o primeiro adaptador, num 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

   where:

   • PROJECT_ID é o ID do Google Cloud projeto que contém o seu armazenamento de HL7v2.
   • LOCATION é a região onde o seu armazenamento de HL7v2 está localizado.
   • DATASET_ID é o ID do conjunto de dados principal do seu armazenamento de HL7v2.
   • HL7V2_STORE_ID é o ID do armazenamento de HL7v2 para o qual está a enviar mensagens HL7v2.
   • PROJECT_ID é o ID do projeto Google Cloud que contém o tópico do Pub/Sub.
   • PUBSUB_SUBSCRIPTION é o nome da primeira subscrição que criou associada ao seu primeiro tópico do Pub/Sub. O adaptador consome mensagens desta subscrição e confirma-as automaticamente.

   Depois de executar este comando, o adaptador começa a ser executado na sua máquina local em 127.0.0.1:2575. Publica novas mensagens no primeiro destinatário externo na porta 2525.

   Importante: se estiver a usar o Mac OS e este comando falhar com um erro Connection refused, consulte o artigo Erro de ligação recusada ao executar localmente. Se este comando falhar com um could not find default credentials erro, consulte o could not find default credentials erro ao executar localmente.

Configurar e iniciar o segundo recetor e adaptador

Para configurar e iniciar o segundo recetor e adaptador, conclua os seguintes passos:

1. Na máquina onde extraiu a imagem Docker pré-criada, execute o seguinte comando para instalar o Netcat:

   sudo apt install netcat
   

2. Transfira hl7v2-mllp-ack-sample.txt, se ainda não o tiver feito. O ficheiro contém uma mensagem ACK usada como resposta pelo adaptador quando tenta publicar uma mensagem.

3. Para definir a porta 2526 para o segundo recetor, 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 Netcat é iniciado, é apresentado o seguinte resultado:

   listening on [any] 2526 ...
   

4. Para iniciar o segundo adaptador, num 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

   where:

   • PROJECT_ID é o ID do Google Cloud projeto que contém o seu armazenamento de HL7v2.
   • LOCATION é a região onde o seu armazenamento de HL7v2 está localizado.
   • DATASET_ID é o ID do conjunto de dados principal do seu armazenamento de HL7v2.
   • HL7V2_STORE_ID é o ID do armazenamento de HL7v2 para o qual está a enviar mensagens HL7v2.
   • PROJECT_ID é o ID do projeto Google Cloud que contém o tópico do Pub/Sub.
   • SECOND_PUBSUB_SUBSCRIPTION é o nome da segunda subscrição que criou associada ao seu segundo tópico do Pub/Sub. O adaptador consome mensagens desta subscrição e confirma-as automaticamente.

   Depois de executar este comando, o adaptador começa a ser executado na sua máquina local no endereço IP 127.0.0.1:2576. Publica novas mensagens no segundo recetor externo na porta 2526.

   Importante: se estiver a usar o Mac OS e este comando falhar com um erro Connection refused, consulte o artigo Erro de ligação recusada ao executar localmente. Se este comando falhar com um erro could not find default credentials., consulte o erro could not find default credentials ao executar localmente.

Publicar uma mensagem no primeiro recetor

Para criar uma mensagem que só vai ser publicada para o primeiro destinatário externo, conclua os seguintes passos:

1. Transfira hl7v2-sample1.json.

2. No diretório onde transferiu hl7v2-sample1.json, chame o método messages.create para criar a mensagem num armazenamento de HL7v2:

   curl

   Para criar uma mensagem HL7v2, faça um pedido POST e especifique as seguintes informações:

   • O nome do conjunto de dados principal
   • O nome do armazenamento de HL7v2
   • Uma mensagem
   • Uma chave de acesso

   O exemplo seguinte mostra um pedido POST com curl e um ficheiro 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 o pedido for bem-sucedido, o servidor devolve 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 um pedido POST e especifique as seguintes informações:

   • O nome do conjunto de dados principal
   • O nome do armazenamento de HL7v2
   • Uma mensagem
   • Uma chave de acesso

   O exemplo seguinte mostra um pedido POST através do Windows PowerShell e um ficheiro JSON de exemplo denominado 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 o pedido for bem-sucedido, o servidor devolve 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 está definido como SEND_FACILITY_1. Por conseguinte, a notificação do Pub/Sub só é enviada para o primeiro tópico do Pub/Sub. Depois de criar a mensagem, o primeiro adaptador MLLP devolve 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 devolve nenhuma resposta porque não é enviada nenhuma notificação para o segundo tópico do Pub/Sub.

   No terminal onde executou o primeiro processo Netcat, é apresentado o seguinte resultado: Este resultado 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^\
   

   Este resultado corresponde ao valor no campo data da resposta que recebeu quando criou a mensagem. É o mesmo que o valor data no ficheiro hl7v2-sample1.json.

Publicar uma mensagem no segundo recetor

Para criar uma mensagem que só vai ser publicada para o segundo destinatário externo, conclua os seguintes passos:

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

2. Para criar uma mensagem que só vai ser publicada no segundo destinatário externo, transfira hl7v2-sample2.json.

3. No diretório onde transferiu hl7v2-sample2.json, chame o método messages.create para criar a mensagem num armazenamento de HL7v2:

   curl

   Para criar uma mensagem HL7v2, faça um pedido POST e especifique as seguintes informações:

   • O nome do conjunto de dados principal
   • O nome do armazenamento de HL7v2
   • Uma mensagem
   • Uma chave de acesso

   O exemplo seguinte mostra um pedido POST com curl e um ficheiro 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 o pedido for bem-sucedido, o servidor devolve 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 um pedido POST e especifique as seguintes informações:

   • O nome do conjunto de dados principal
   • O nome do armazenamento de HL7v2
   • Uma mensagem
   • Uma chave de acesso

   O exemplo seguinte mostra um pedido POST através do Windows PowerShell e um ficheiro 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 o pedido for bem-sucedido, o servidor devolve 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"
      }
    ]
   }
   

   Tenha em atenção que o sendFacility é SEND_FACILITY_2, pelo que a notificação do Pub/Sub só é enviada para o segundo tópico do Pub/Sub. Após a criação da mensagem, o primeiro adaptador MLLP não devolve qualquer resposta, enquanto o segundo adaptador MLLP devolve 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 onde executou o segundo processo Netcat, é apresentado o seguinte resultado. Este resultado 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^\
   

   Este resultado corresponde ao valor no campo data da resposta que recebeu quando criou a mensagem. É o mesmo que o valor data no ficheiro hl7v2-sample2.json.

Implementar o adaptador MLLP no Google Kubernetes Engine

Quando transmite mensagens HL7v2 através de MLLP a partir do seu centro de cuidados, uma configuração possível é enviar as mensagens para um adaptador implementado noGoogle Cloud e que as pode encaminhar para a Cloud Healthcare API.

O adaptador MLLP é executado como uma aplicação sem estado num cluster do GKE. Um cluster do GKE é um grupo gerido de instâncias de VM para executar aplicações contentorizadas. As aplicações sem estado são aplicações que não armazenam dados nem o estado da aplicação no cluster ou no armazenamento persistente. Em alternativa, os dados e o estado da aplicação permanecem com o cliente, o que torna as aplicações sem estado mais escaláveis.

O GKE usa o controlador de implementação para implementar aplicações sem estado como pods uniformes e não únicos. As implementações gerem o estado pretendido da sua aplicação: quantos pods devem executar a sua aplicação, que versão da imagem do contentor deve ser executada, que etiquetas devem ser atribuídas aos pods, etc. O estado pretendido pode ser alterado dinamicamente através de atualizações à especificação do pod da implementação.

Ao mesmo tempo que implementa o adaptador, cria um controlador de serviço que lhe permite ligar o adaptador à Cloud Healthcare API através do balanceamento de carga interno.

Se não tem experiência com o GKE, deve concluir o início rápido do GKE para saber como o produto funciona.

Adicionar autorizações da API Pub/Sub à conta de serviço do GKE

Conforme indicado na documentação do GKE sobre a autenticação na Cloud Platform com contas de serviço, cada nó num cluster de contentores é uma instância do Compute Engine. Por conseguinte, quando o adaptador MLLP é executado num cluster de contentores, herda automaticamente os âmbitos das instâncias do Compute Engine nas quais é implementado.

Google Cloud cria automaticamente uma conta de serviço denominada "Conta de serviço predefinida do Compute Engine" e o GKE associa esta conta de serviço aos nós que o GKE cria. Consoante a configuração do seu projeto, a conta de serviço predefinida pode ou não ter autorizações para usar outras APIs da Cloud Platform. O GKE também atribui alguns âmbitos de acesso limitado às instâncias do Compute Engine.

Para obter os melhores resultados, não faça a autenticação noutros Google Cloud serviços (como o Pub/Sub) a partir de pods executados no GKE atualizando as autorizações da conta de serviço predefinida ou atribuindo mais âmbitos de acesso a instâncias do Compute Engine. Em alternativa, crie as suas próprias contas de serviço.

Tem de conceder as autorizações do Pub/Sub necessárias ao cluster do contentor, mas também tem a opção de conceder autorizações para escrever métricas no Cloud Monitoring.

Para criar uma nova conta de serviço que contenha apenas os âmbitos necessários para o cluster do contentor, conclua os seguintes passos:

Consola

Crie uma conta de serviço:

1. Na Google Cloud consola, aceda à página Criar conta de serviço.

   Aceda a Criar conta de serviço

2. Selecione um projeto.

3. No campo Nome da conta de serviço, introduza um nome. A Google Cloud consola preenche o campo ID da conta de serviço com base neste nome.

   Opcional: no campo Descrição da conta de serviço, introduza uma descrição.

4. Clique em Criar.

5. Clique no campo Selecionar uma função.

   Em Todas as funções, clique em Pub/Sub > Subscritor do Pub/Sub.

6. Clique em Adicionar outra função e, de seguida, clique no campo Selecionar uma função.

   Em Todas as funções, clique em Cloud Healthcare > Carregar mensagens de HL7v2 da Healthcare.

7. Opcional: se quiser ativar a monitorização, clique em Adicionar outra função e, de seguida, clique no campo Selecionar uma função.

   Em Todas as funções, clique em Monitorização > Escritor de métricas de monitorização.

8. Clique em Continuar.

9. Clique em Concluído para terminar de criar a conta de serviço.

   Não feche a janela do navegador. Vai usar a janela no procedimento seguinte.

gcloud

1. Para criar a conta de serviço, execute o comando gcloud iam service-accounts create.

   gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

   O resultado é a conta de serviço:

   Created service account SERVICE_ACCOUNT_NAME.

2. Para conceder cada função à conta de serviço, execute o 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

   A saída inclui a política atualizada:

   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

A 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

where:

• COMPUTE_ZONE é a zona na qual o seu cluster está implementado. Uma zona é uma localização regional aproximada na qual os seus clusters e respetivos recursos residem. Por exemplo, us-west1-a é uma zona na região us-west. Se tiver definido uma zona predefinida através de gcloud config set compute/zone, o valor deste sinalizador substitui o valor predefinido.
• CLIENT_EMAIL é o identificador da conta de serviço que quer usar. Usa o formato SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.

O comando devolve um resultado semelhante ao seguinte exemplo:

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. Pode verificar isso listando as instâncias com o seguinte comando:

gcloud compute instances list

Configurar a implementação

Quando implementa uma aplicação no GKE, define as propriedades da implementação através de um ficheiro de manifesto de implementação, que é normalmente um ficheiro YAML. Para ver um exemplo, consulte o artigo Criar uma implementação.

1. Abra um terminal separado.

2. Com um editor de texto, crie um ficheiro de manifesto de implementação denominado 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"

where:

• PROJECT_ID é o ID do Google Cloud projeto que contém o seu armazenamento de HL7v2.
• LOCATION é a região onde o seu armazenamento de HL7v2 está localizado.
• DATASET_ID é o ID do conjunto de dados principal do seu armazenamento de HL7v2.
• HL7V2_STORE_ID é o ID do armazenamento de HL7v2 para o qual está a enviar mensagens HL7v2.

A implementação tem as seguintes propriedades:

• spec: replicas: é o número de agrupamentos replicados que a implementação gere.
• spec: template: metadata: labels: é a etiqueta atribuída a cada Pod, que a implementação usa para gerir os pods.
• spec: template: spec: é a especificação do agrupamento, que define como cada agrupamento deve ser executado.
• spec: containers inclui o nome do contentor a ser executado em cada Pod e a imagem do contentor que deve ser executada.

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

Configurar o serviço

Para tornar o adaptador MLLP acessível a aplicações fora do cluster (como um centro de cuidados), tem de configurar um equilibrador de carga interno.

Se não tiver configurado uma VPN, as aplicações podem aceder ao adaptador MLLP através do equilibrador de carga interno, desde que usem a mesma rede VPC e estejam localizadas na mesma Google Cloud região. 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, pode adicionar um balanceador de carga interno ao recurso Service do cluster.

No diretório onde criou o ficheiro de manifesto de implementação, use o editor de texto para criar um ficheiro de manifesto de serviço denominado mllp_adapter_service.yaml com o seguinte conteúdo. Este ficheiro é responsável pela configuração do 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 que escolhe para o serviço. Neste caso, é mllp-adapter-service.
• metadata: annotations: é uma anotação que especifica que deve ser configurado um equilibrador de carga interno.
• spec: type: é o tipo de balanceador de carga.
• ports: port: é usado para especificar a porta na qual o serviço pode receber tráfego de outros serviços no mesmo cluster. É usada a porta MLLP predefinida de 2575.
• ports: targetPort: é usado para especificar a porta em cada Pod onde 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 equilibrador de carga (através do campo clusterIP), o equilibrador de carga pode gerar o seu próprio endereço IP para o qual pode enviar mensagens. Por agora, deixe o cluster gerar o endereço IP, que vai usar mais tarde neste tutorial.

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

Para mais informações sobre a especificação do serviço, consulte a referência da API Service.

Implementar a implementação

Para implementar o adaptador num cluster do GKE, no diretório que contém o ficheiro do manifesto de implementação mllp_adapter.yaml, execute o seguinte comando:

kubectl apply -f mllp_adapter.yaml

O comando devolve o seguinte resultado:

deployment.extensions "mllp-adapter-deployment" created

Nota: kubectl apply falha se não tiver um cluster ativo.

A inspecionar a implementação

Depois de criar a implementação, pode usar a ferramenta kubectl para inspecioná-la.

Para obter informações detalhadas sobre a implementação, execute o seguinte comando:

kubectl describe deployment mllp-adapter

Para apresentar uma lista do pod criado pela implementação, execute o seguinte comando:

kubectl get pods -l app=mllp-adapter

Para obter informações sobre o Pod criado:

kubectl describe pod POD_NAME

Se a implementação foi bem-sucedida, a última parte do resultado do comando anterior deve 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

Implementar o serviço e criar o balanceador de carga interno

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

kubectl apply -f mllp_adapter_service.yaml

O comando devolve o seguinte resultado:

service "mllp-adapter-service" created

Nota: kubectl apply falha se não tiver um cluster ativo.

Inspeção do serviço

Depois de criar o serviço, inspecione-o para verificar se foi configurado com êxito.

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

kubectl describe service mllp-adapter-service

A saída do comando é semelhante ao seguinte exemplo:

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

Nota: quando visualiza o resultado, IP e LoadBalancer Ingress não têm o mesmo valor. Aqui, usam o mesmo valor para fins de demonstração.

O endereço IP LoadBalancer Ingress pode demorar até um minuto a ser preenchido. Vai usar este endereço IP e a porta 2575 para aceder ao serviço a partir de fora do cluster no passo seguinte.

Criar uma VM do Compute Engine e enviar mensagens

Enquanto anteriormente neste tutorial testou o adaptador MLLP localmente e enviou mensagens HL7v2 para o seu armazenamento HL7v2, agora vai enviar mensagens de uma VM do Compute Engine para o adaptador MLLP em execução no GKE. As mensagens são, em seguida, encaminhadas para um armazenamento de HL7v2.

Para enviar pedidos da nova instância para o cluster do GKE, a instância e as instâncias existentes têm de estar na mesma região e usar a mesma rede de VPC.

No final desta secção, vai apresentar em lista as notificações publicadas no seu tópico do Pub/Sub e as mensagens HL7v2 no seu armazenamento HL7v2. Tem de conceder autorizações à instância de VM do Compute Engine para realizar estas tarefas. Antes de criar a instância, crie uma nova conta de serviço com as autorizações necessárias seguindo estes passos:

Consola

Crie uma conta de serviço:

1. Na Google Cloud consola, aceda à página Criar conta de serviço.

   Aceda a Criar conta de serviço

2. Selecione um projeto.

3. No campo Nome da conta de serviço, introduza um nome. A Google Cloud consola preenche o campo ID da conta de serviço com base neste nome.

   Opcional: no campo Descrição da conta de serviço, introduza uma descrição.

4. Clique em Criar.

5. Clique no campo Selecionar uma função.

   Em Todas as funções, clique em Pub/Sub > Subscritor do Pub/Sub.

6. Clique em Adicionar outra função e, de seguida, clique no campo Selecionar uma função.

   Em Todas as funções, clique em Cloud Healthcare > Consumidor de mensagens de HL7v2 da Healthcare.

7. Clique em Continuar.

8. Clique em Concluído para terminar de criar a conta de serviço.

   Não feche a janela do navegador. Vai usar a janela no procedimento seguinte.

gcloud

1. Para criar a conta de serviço, execute o comando gcloud iam service-accounts create.

   gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

   O resultado é a conta de serviço:

   Created service account SERVICE_ACCOUNT_NAME.

2. Para conceder cada função à conta de serviço, execute o 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

   A saída inclui a política atualizada:

   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

Os passos seguintes mostram como criar uma instância de máquina virtual Linux no Compute Engine:

Consola

1. Na Google Cloud consola, aceda à página Instâncias de VM.

   Aceda à página Instâncias de VM

2. Clique em Criar instância.

3. Escolha uma Região e uma Zona para a instância que corresponda à zona que selecionou quando criou o cluster. Por exemplo, se usou us-central1-a para o COMPUTE_ZONE quando criou o cluster, no ecrã de criação de instâncias, selecione us-central1 (Iowa) para a região e us-central1-a para a zona.

4. Na secção Disco de arranque, clique em Alterar para começar a configurar o seu disco de arranque.

5. No separador Imagens públicas, escolha a versão 9 do sistema operativo Debian.

6. Clique em Selecionar.

7. Na secção Identidade e acesso à API, selecione a conta de serviço que criou.

8. Na secção Firewall, selecione Permitir tráfego HTTP.

9. Clique em Criar para criar a instância.

gcloud

Para criar uma instância de computação, execute o método gcloud compute instances create com as seguintes opções:

• O ZONE que selecionou quando criou o cluster
• A etiqueta http-server para permitir o tráfego HTTP
• O SERVICE_ACCOUNT que criou

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

O resultado é semelhante ao seguinte exemplo:

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 algum tempo para que a instância seja iniciada. Depois de iniciar a instância, esta é apresentada na página Instâncias de VM com um ícone de estado verde.

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

Para estabelecer ligação à instância, conclua os seguintes passos:

Consola

1. Na Google Cloud consola, aceda à página Instâncias de VM.

   Aceda à página Instâncias de VM

2. Na lista de instâncias de máquinas virtuais, clique em SSH na linha da instância que criou.

gcloud

Para se ligar à instância, execute o comando gcloud compute ssh:

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

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

1. Na janela de terminal, instale o Netcat:

   sudo apt install netcat
   

2. Transfira o ficheiro hl7v2-mllp-sample.txt e guarde-o na instância. Para obter informações sobre a codificação e os terminadores de segmentos usados no ficheiro, consulte o artigo Separadores de segmentos e codificação de mensagens HL7v2.

3. Para começar a enviar mensagens HL7v2 através do adaptador MLLP para o seu armazenamento HL7v2, no diretório onde transferiu o ficheiro, execute o seguinte comando. Use o valor de LoadBalancer Ingress que foi apresentado quando inspecionou o Serviço.

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

   Após a execução do comando, a mensagem é enviada através do adaptador MLLP para o seu armazenamento HL7v2. Se a mensagem tiver sido carregada com êxito no arquivo HL7v2, o comando devolve o seguinte resultado:

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

   Este resultado indica que o arquivo HL7v2 respondeu com um tipo de resposta AA (Application Accept), o que significa que a mensagem foi validada e carregada com êxito.

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

   gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION

   O comando devolve a seguinte saída sobre a mensagem HL7v2 carregada:

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

5. Também pode apresentar as mensagens na sua loja 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 o pedido for bem-sucedido, o servidor devolve o ID da mensagem num caminho do 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 o pedido for bem-sucedido, o servidor devolve o ID da mensagem num caminho do recurso:

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

Depois de concluir esta secção, implementou com êxito o adaptador MLLP no GKE e enviou uma mensagem HL7v2 a partir de uma instância remota através do adaptador e para a Cloud Healthcare API.

No resto deste tutorial, vai aprender a encriptar de forma segura as mensagens HL7v2 transmitidas configurando uma VPN entre uma instância do Compute Engine, que funciona como uma instância "no local", e o adaptador.

Configurar uma VPN

A utilização de uma VPN permite-lhe expandir a rede privada na qual envia mensagens HL7v2 através de uma rede pública, como a Internet. Ao usar uma VPN, pode enviar mensagens do seu centro de cuidados através do adaptador MLLP e para Google Cloud. Os sistemas neste fluxo atuam como se estivessem numa única rede privada.

Existem dois métodos para proteger a sua ligação MLLP através de VPN:

• Usar a Cloud VPN
• Usar a solução de VPN ponto a ponto Strongswan no Docker

Configurar o Cloud VPN

O Cloud VPN liga em segurança a sua rede no local à sua rede deGoogle Cloud nuvem virtual privada (VPC) através de uma ligação VPN IPsec. O tráfego que viaja entre as duas redes é encriptado por um gateway de VPN e, em seguida, desencriptado pelo outro gateway de VPN. Isto protege os seus dados à medida que transitam através da Internet ou através de uma rede de um centro de cuidados.

Neste tutorial, cada gateway de VPN que configurar está localizado numa rede personalizada e numa sub-rede diferentes numa região diferente. Google Cloud

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

Referência de nomenclatura e endereçamento

Para referência, este tutorial usa a seguinte nomenclatura e endereçamento IP:

Google Cloud lado

• Nome da rede: cloud-vpn-network
• Nome da sub-rede: subnet-us-central-10-0-1
• Região: us-central1
• Intervalo de 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 de VPN: vpn-us-central-tunnel-1

Lado "no local"

• Nome da rede: on-prem-vpn-network
• Nome da sub-rede: subnet-europe-west-10-0-2
• Região: europe-west1
• Intervalo de 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 de VPN: vpn-europe-west-tunnel-1

Criar sub-redes e redes VPC personalizadas

O primeiro passo na configuração do Cloud VPN é criar duas redes VPC. Uma rede, denominada on-prem-vpn-network, está configurada no ambiente "no local" e é executada numa instância de VM do Compute Engine denominada on-prem-instance. A outra rede, denominada cloud-vpn-network, é a que o cluster do GKE que executa o adaptador MLLP usa. Estabelece ligação à VM on-prem-instance e envia mensagens HL7v2 para o adaptador MLLP em execução na rede cloud-vpn-network através do balanceador de carga interno do adaptador MLLP.

Crie duas redes VPC personalizadas e as respetivas sub-redes concluindo os seguintes passos:

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

Criar um endereço IP externo

Antes de criar os gateways de VPN, reserve um endereço IP externo para cada gateway através dos seguintes passos:

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. Tome nota dos endereços IP externos para os poder usar para configurar os gateways de VPN na secção seguinte. Para obter os endereços IP externos, execute o seguinte comando:

   Endereço IP da Cloud VPN:

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

   Endereço IP da VPN"no local":

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

   Os comandos devolvem um resultado semelhante ao seguinte:

   address: 203.0.113.1
   

Criar os gateways, os túneis e os trajetos de VPN

Conclua os passos seguintes para criar o gateway de VPN, o túnel e a rota para a Cloud VPN:

1. Crie uma chave pré-partilhada (segredo partilhado) criptograficamente forte seguindo as instruções em Gerar uma chave pré-partilhada forte. Esta chave é referida como SHARED_SECRET nesta secção.

2. Para criar o objeto gateway de 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 da VPN na nuvem na secção anterior:

   Enviar 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

   Enviar 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 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 de VPN do Google Cloud, execute o seguinte comando. Substitua ON_PREM_VPN_IP pelo valor do endereço IP da VPN"No local" na secçã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 os passos seguintes para criar o gateway de VPN, o túnel e a rota para a VPN "no local":

1. Para criar o objeto gateway de 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"No local" na secção anterior:

   Enviar 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

   Enviar 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 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 "no 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"

Criou a VPN na nuvem e os gateways "no local" e iniciou os respetivos túneis. Os gateways de VPN não se ligam até criar regras de firewall para permitir o tráfego através do túnel entre eles.

Criar regras de firewall

Tem de criar regras de firewall para ambos os lados do túnel de VPN. Estas regras permitem que todo o tráfego TCP, UDP e ICMP entre a partir da sub-rede de um lado do túnel de VPN para o outro.

1. Para criar as regras de firewall para a sub-rede da VPN na nuvem, 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 "no 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 lhe permita usar 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

Verificar o estado do túnel VPN

Para verificar se o túnel está ativo, conclua os seguintes passos:

1. Aceda à página da VPN na Google Cloud consola.

   Aceda à página da VPN

2. Clique no separador Túneis de VPN da Google.

3. No campo Estado de cada túnel, procure uma marca de verificação verde e a palavra "Estabelecido". Se estes itens estiverem presentes, os gateways negociaram um túnel. Se não aparecer nenhuma marca após alguns minutos, consulte a secção Resolução de problemas.

   Para obter informações de registo adicionais relacionadas com os seus túneis de VPN, consulte o artigo Verificar registos de VPN na página de resolução de problemas. Por exemplo, pode ver métricas sobre pacotes perdidos, estado do túnel, bytes recebidos e bytes enviados.

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

Combinar a implementação no GKE e no Cloud VPN

Enquanto anteriormente neste tutorial testou o adaptador MLLP localmente e enviou mensagens HL7v2 através de uma ligação não VPN para o adaptador MLLP, vai agora enviar mensagens a partir de uma VM do Compute Engine através de uma ligação segura com a Cloud VPN para o adaptador MLLP em execução no GKE. As mensagens são, em seguida, encaminhadas para um armazenamento de HL7v2.

Recriar a implementação

Primeiro, recrie a implementação no GKE para que o cluster use as definições que configurou em Configurar o Cloud VPN:

1. Para eliminar o cluster mllp-adapter que criou, execute o comando gcloud container clusters delete. Introduza o valor COMPUTE_ZONE que usou quando criou o cluster.

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

2. Siga os passos em Implementar o adaptador MLLP no Kubernetes Engine, mas, quando criar o cluster no GKE, adicione a rede cloud-vpn-network e a sub-rede subnet-us-central-10-0-1 que criou em Criar sub-redes e redes VPN personalizadas.

   Certifique-se de que o comando de criação do cluster tem o seguinte aspeto:

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

   where:

   • COMPUTE_ZONE é a zona na qual o seu cluster está implementado. Quando configurou a Cloud VPN na secção anterior, definiu a rede do "lado"Google Cloud para usar us-central1. Esta rede "Google Cloud lateral" é aquela em que 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.

     Nota: o cluster do GKE e a rede "Google Cloud lateral" têm de estar na mesma região. Caso contrário, o encaminhamento não funciona.

   • CLIENT_EMAIL é o identificador da conta de serviço que quer usar. Usa o formato SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.

Criar uma nova VM do Compute Engine com definições de rede

Os passos seguintes mostram como criar uma instância de máquina virtual Linux no Compute Engine através da Google Cloud consola. Ao contrário da VM do Compute Engine que criou, esta VM usa as definições de rede "no local" para comunicar com o cluster do GKE através de uma VPN.

Consola

1. Na Google Cloud consola, aceda à página Instâncias de VM.

   Aceda à página Instâncias de VM

2. Clique em Criar instância.

3. Escolha uma Região e uma Zona para a instância que corresponda às definições de rede do "lado local": europe-west1 (Belgium) para a Região e europe-west1-b para a Zona.

4. Na secção Disco de arranque, clique em Alterar para começar a configurar o disco de arranque.

5. No separador Imagens públicas, escolha a versão 9 do sistema operativo Debian.

6. Clique em Selecionar.

7. Na secção Identidade e acesso à API, selecione a conta de serviço que criou.

8. Na secção Firewall, selecione Permitir tráfego HTTP.

9. Expanda a secção Gestão, segurança, discos, trabalhar em rede, arrendamento único.

10. Em Interfaces de rede no separador Redes, especifique os detalhes da rede para as definições de rede "no local":

    1. No campo Rede, selecione on-prem-vpn-network.
    2. No campo Sub-rede, selecione subnet-europe-west-10-0-2 (10.0.2.0/24).

11. Clique em Criar para criar a instância.

Aguarde algum tempo para que a instância seja iniciada. Quando estiver pronta, é apresentada na página Instâncias de VM com um ícone de estado verde.

gcloud

Para criar uma instância de computação, execute o método gcloud compute instances create com as seguintes opções:

• O ZONE que corresponde às definições de rede do lado "no local": europe-west1-b para a zona.
• Permita o tráfego HTTP especificando a etiqueta http-server
• O SERVICE_ACCOUNT que criou

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

O resultado é semelhante ao seguinte exemplo:

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 estabelecer ligação à instância, conclua os seguintes passos:

Consola

1. Na Google Cloud consola, aceda à página Instâncias de VM.

   Aceda à página Instâncias de VM

2. Na lista de instâncias de máquinas virtuais, clique em SSH na linha da instância que criou.

gcloud

Para se ligar à instância, execute o comando gcloud compute ssh:

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

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

1. Na janela de terminal, instale o Netcat:

   sudo apt install netcat
   

2. Transfira o ficheiro hl7v2-mllp-sample.txt e guarde-o na instância.

3. Para começar a enviar mensagens HL7v2 através do adaptador MLLP para o seu armazenamento HL7v2, no diretório onde transferiu o ficheiro, execute o seguinte comando. Use o valor de LoadBalancer Ingress que foi apresentado quando inspecionou o Serviço.

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

   Após a execução do comando, a mensagem é enviada através do adaptador MLLP para o seu armazenamento HL7v2. Se a mensagem tiver sido carregada com êxito no arquivo HL7v2, o comando devolve o seguinte resultado:

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

   Este resultado indica que o armazenamento HL7v2 respondeu com um tipo de resposta AA (Application Accept), o que significa que a mensagem foi validada e carregada com êxito.

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

   gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION

   O comando devolve a seguinte saída sobre a mensagem HL7v2 carregada:

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

5. Também pode apresentar as mensagens na sua loja 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 o pedido for bem-sucedido, o servidor devolve o ID da mensagem num caminho do 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 o pedido for bem-sucedido, o servidor devolve o ID da mensagem num caminho de recurso:

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

Depois de concluir esta secção, implementou com êxito o adaptador MLLP no GKE e, através de uma VPN, enviou em segurança uma mensagem HL7v2 de uma instância "no local" através do adaptador e para a Cloud Healthcare API.

Limpar

Para evitar incorrer em custos na sua Google Cloud conta pelos recursos usados neste tutorial, pode limpar os recursos que criou em Google Cloud.

Elimine o projeto

Siga os passos abaixo para eliminar o projeto que criou neste tutorial:

Atenção: a eliminação de um projeto tem os seguintes efeitos:

• Tudo no projeto é eliminado. Se usou um projeto existente para as tarefas neste documento, quando o elimina, também elimina qualquer outro trabalho que tenha feito no projeto.
• Os IDs dos projetos personalizados são perdidos. Quando criou este projeto, pode ter criado um ID do projeto personalizado que quer usar no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, elimine os recursos selecionados no projeto em vez de eliminar o projeto inteiro.

Se planeia explorar várias arquiteturas, tutoriais ou inícios rápidos, a reutilização de projetos pode ajudar a evitar exceder os limites de quota de projetos.

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.

Resolução de problemas

Falhas do transformador

Após a implementação do adaptador MLLP no GKE, o adaptador encontra uma falha.

• Siga os passos em Resolução de problemas com cargas de trabalho implementadas.

Erro Connection refused ao executar localmente

Quando testa o adaptador MLLP localmente, encontra o erro Connection refused.

• Este erro ocorre com alguns utilizadores do Mac OS. Em vez de usar a flag --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 o seguinte aspeto:

  Nota: quando fornecer um valor para --pubsub_subscription, introduza apenas o nome da subscrição; não introduza o URI completo. Por exemplo, se o URI da sua subscrição for projects/my-projects/subscriptions/my-subscription, indique apenas my-subscription.

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

Erro could not find default credentials ao executar localmente

Quando testa o adaptador MLLP localmente, encontra o erro healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials..

Este erro ocorre quando o adaptador não consegue encontrar as suas credenciais da ADC locais. Certifique-se de que configurou as Credenciais padrão da aplicação no seu ambiente local.

Erros de autenticação

Se encontrar erros de autenticação ao testar o adaptador MLLP localmente que não estejam abrangidos no resto desta secção, volte a executar o comando docker run e adicione a flag -v ~/.config:/root/.config no final do comando, da seguinte forma:

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