Como transmitir mensagens HL7v2 por conexões TCP/IP

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

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

Objetivos

Depois de concluir este tutorial, você saberá:

Custos

Neste tutorial, há componentes faturáveis do Google Cloud, a saber:

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

Use a calculadora de preços para gerar uma estimativa de custo baseada na projeção de uso. Usuários novos do Cloud Platform podem se qualificar para uma avaliação gratuita.

Antes de começar

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

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

  1. Faça login na sua conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. No Console do Cloud, na página do seletor de projetos, selecione ou crie um projeto do Cloud.

    Acessar a página do seletor de projetos

  3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como confirmar se a cobrança está ativada para o seu projeto.

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

    Ative as APIs

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

Como escolher um shell

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

O Cloud Shell é um ambiente de shell para gerenciar recursos hospedados no Google Cloud. O Cloud Shell vem pré-instalado com as ferramentas gcloud e kubectl. A ferramenta gcloud fornece a interface de linha de comando principal para o GCP. kubectl fornece a interface de linha de comando para executar comandos nos clusters do GKE.

Se você preferir usar o shell local, instale o SDK do Cloud, que inclui a ferramenta gcloud e a ferramenta kubectl.

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

Cloud Shell

Para iniciar o Cloud Shell, siga estas etapas:

  1. Acesse o Console do Google Cloud.

    Console do Google Cloud

  2. No canto superior direito do console, clique no botão Ativar o Cloud Shell:

Uma sessão do Cloud Shell é aberta dentro de um frame na parte inferior do console. Use esse shell para executar os comandos gcloud e kubectl.

Shell local

Para instalar a ferramenta gcloud e a ferramenta kubectl, siga estas etapas:

  1. Instale e inicie o SDK do Cloud.
  2. Se você estiver apenas testando o adaptador localmente, não precisará concluir mais etapas e poderá continuar em Como criar um conjunto de dados. Se você estiver implantando o adaptador no GKE, instale a ferramenta de linha de comando kubectl executando o seguinte comando:

    gcloud components install kubectl

Como criar um conjunto de dados

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

Console

  1. No Console do Cloud, acesse a página "Conjuntos de dados".

    Acessar a página "Conjuntos de dados"

  2. Clique em Criar conjunto de dados.
  3. Escolha um identificador de conjunto de dados exclusivo no projeto e na região. Se o identificador não for exclusivo, a criação do conjunto de dados falhará.
  4. Escolha a região em que o conjunto de dados reside permanentemente e clique em Criar.

O novo conjunto de dados é exibido na lista.

gcloud

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

gcloud healthcare datasets create DATASET_ID \
    --location=LOCATION

Se a solicitação for bem-sucedida, o comando retornará a seguinte saída:

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

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

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

Para criar um tópico, siga estas etapas:

Console

  1. Acesse a página de tópicos do Pub/Sub no Console do Cloud:

    Acessar a página de tópicos do Cloud Pub/Sub

  2. Clique em Criar tópico.

  3. Digite um nome de tópico com o URI:

    projects/PROJECT_ID/topics/TOPIC_NAME

    em que PROJECT_ID é o ID do projeto no Google Cloud.

  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 a solicitação for bem-sucedida, o comando retornará a seguinte saída:

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

Para criar uma assinatura, conclua as etapas a seguir:

Console

  1. Acesse a página de tópicos do Pub/Sub no Console do Cloud:

    Acessar a página de tópicos do Cloud Pub/Sub

  2. Clique no tópico do projeto.

  3. Clique em Criar assinatura.

  4. Insira o nome da assinatura:

    projects/PROJECT_ID/subscriptions/SUBSCRIPTION_NAME

  5. Deixe Tipo de entrega definido como Pull e clique em Criar.

gcloud

Para criar uma assinatura, execute o comando gcloud pubsub subscriptions create:

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

Se a solicitação for bem-sucedida, o comando retornará a seguinte saída:

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

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

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

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

curl

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

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

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

PowerShell

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

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

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

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

Configurar permissões do Pub/Sub

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

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

Console

  1. Na página do IAM no Console do Cloud, verifique se o papel Agente de serviço do Healthcare aparece no Papel para a conta de serviço do projeto relevante. O nome da conta é service-PROJECT_NUMBER@gcp-sa-healthcare.iam.gserviceaccount.com. Para informações sobre como encontrar o PROJECT_NUMBER, consulte Como identificar projetos.

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

  3. Clique em Adicionar outro papel e pesquise o papel Editor do Pub/Sub.

  4. Selecione o papel e clique em Salvar. O papel pubsub.publisher é adicionado à conta de serviço.

gcloud

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

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

Como extrair a imagem pré-criada do Docker

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

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

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

Como testar o adaptador MLLP localmente

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

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

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

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

Como testar o adaptador MLLP localmente como um receptor

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

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

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

    docker run \
        --network=host \
        -v ~/.config:/root/.config \
        gcr.io/cloud-healthcare-containers/mllp-adapter \
        /usr/mllp_adapter/mllp_adapter \
        --hl7_v2_project_id=PROJECT_ID \
        --hl7_v2_location_id=LOCATION \
        --hl7_v2_dataset_id=DATASET_ID \
        --hl7_v2_store_id=HL7V2_STORE_ID \
        --export_stats=false \
        --receiver_ip=0.0.0.0 \
        --port=2575 \
        --api_addr_prefix=https://healthcare.googleapis.com:443/v1 \
        --logtostderr
    

    onde:

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

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

    I0000 00:00:00.000000      1 healthapiclient.go:171] Dialing connection to https://healthcare.googleapis.com:443/v1
    I0000 00:00:00.000000      1 mllp_adapter.go:89] Either --pubsub_project_id or --pubsub_subscription is not provided, notifications of the new messages are not read and no outgoing messages will be sent to the target MLLP address.
    
  2. Para continuar os testes enquanto o adaptador é executado como um processo em primeiro plano, abra um terminal diferente na máquina local.

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

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

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

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

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

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

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

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

     I0000 00:00:00.000000       1 healthapiclient.go:171] Dialing connection to https://healthcare.googleapis.com:443/v1
     I0000 00:00:00.000000       1 mllp_adapter.go:89] Either --pubsub_project_id or --pubsub_subscription is not provided, notifications of the new messages are not read and no outgoing messages will be sent to the target MLLP address.
     I0213 00:00:00.000000       1 healthapiclient.go:190] Sending message of size 319.
     I0213 00:00:00.000000       1 healthapiclient.go:223] Message was successfully sent.
    
  7. A mensagem é armazenada em seu armazenamento HL7v2, então você pode chamar messages.list para ver a mensagem:

    curl

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

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

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

    PowerShell

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

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

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

Como testar o adaptador MLLP localmente como um editor

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

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

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

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

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

Console

  1. Acesse a página de tópicos do Pub/Sub no Console do Cloud:

    Acessar a página de tópicos do Cloud Pub/Sub

  2. Clique no tópico do projeto. Esse é o tópico que você usou para criar a assinatura inicial.

  3. Clique em Criar assinatura.

  4. Insira o nome da assinatura:

    projects/PROJECT_ID/subscriptions/SECOND_SUBSCRIPTION_NAME

    Deixe o Tipo de entrega configurado como Pull.

  5. Clique em Criar.

gcloud

Para criar uma segunda assinatura do Pub/Sub atribuída ao tópico criado anteriormente, execute o comando gcloud pubsub subscriptions create:

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

Se a solicitação for bem-sucedida, o comando retornará a seguinte saída:

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

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

  1. Instale o Netcat:

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

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

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

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

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

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

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

    onde:

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

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

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

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

    curl

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

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

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

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

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

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

    PowerShell

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

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

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

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

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

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

    Depois de criar a mensagem, o adaptador MLLP retorna 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.
    
  7. No terminal em que você executou o Netcat, uma saída semelhante à amostra a seguir é exibida. Esta saída indica que a mensagem foi publicada:

    connect to [127.0.0.1] from localhost [127.0.0.1] 39522
    ^KMSH|^~\&|A|SEND_FACILITY|A|A|20180101000000||TYPE^A|20180101000000|T|0.0|||AA||00|ASCII^MEVN|A00|20180101040000^MPID||14^A111^^^^MRN|11111111^^^^MRN~1111111111^^^^ORGNMBR^\
    

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

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

    gcloud pubsub subscriptions pull --auto-ack SECOND_SUBSCRIPTION
    

    O comando retorna a seguinte saída sobre a mensagem HL7v2 criada. Observe o valor publish=true na coluna ATTRIBUTES, que indica que a mensagem foi publicada no Pub/Sub:

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

Como publicar mensagens em diferentes receptores externos

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

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

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

  2. Execute este comando:

    curl

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

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

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

    PowerShell

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

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

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

Como testar o roteamento de mensagens

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

Como configurar e iniciar o primeiro receptor e adaptador

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

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

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

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

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

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

    listening on [any] 2525 ...
    
  4. Para iniciar o primeiro adaptador, em um novo terminal, execute o seguinte comando:

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

    onde:

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

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

Como configurar e iniciar o segundo receptor e adaptador

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

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

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

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

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

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

    listening on [any] 2526 ...
    
  4. Para iniciar o segundo adaptador, em um novo terminal, execute o seguinte comando:

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

    onde:

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

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

Como publicar uma mensagem no primeiro destinatário

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

  1. Download hl7v2-sample1.json.

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

    curl

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

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

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

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

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

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

    PowerShell

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

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

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

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

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

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

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

    I0214 00:00:00.000000       1 healthapiclient.go:266] Started to fetch message.
    I0214 00:00:00.000000       1 healthapiclient.go:283] Message was successfully fetched.
    

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

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

    connect to [127.0.0.1] from localhost [127.0.0.1] 39522
    ^KMSH|^~\&|A|SEND_FACILITY_1|A|A|20180101000000||TYPE^A|20180101000000|T|0.0|||AA||00|ASCII^MEVN|A00|20180101040000^MPID||14^A111^^^^MRN|11111111^^^^MRN~1111111111^^^^ORGNMBR^\
    

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

Como publicar uma mensagem no segundo destinatário

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

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

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

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

    curl

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

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

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

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

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

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

    PowerShell

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

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

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

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

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

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

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

    I0214 00:00:00.000000       1 healthapiclient.go:266] Started to fetch message.
    I0214 00:00:00.000000       1 healthapiclient.go:283] Message was successfully fetched.
    

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

    connect to [127.0.0.1] from localhost [127.0.0.1] 39522
    ^KMSH|^~\&|A|SEND_FACILITY_2|A|A|20180101000000||TYPE^A|20180101000000|T|0.0|||AA||00|ASCII^MEVN|A00|20180101040000^MPID||14^A111^^^^MRN|11111111^^^^MRN~1111111111^^^^ORGNMBR^\
    

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

Como implantar o adaptador MLLP no Google Kubernetes Engine

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

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

O GKE usa o controlador de implantação para implantar aplicativos sem estado como pods uniforme e não exclusivos. As implantações gerenciam o estado pretendido do aplicativo: quantos pods executarão seu aplicativo, qual versão da imagem do container será executada, como os pods serão rotulados e assim por diante. O estado pretendido pode ser alterado dinamicamente por meio de atualizações na especificação de pod da implantação.

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

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

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

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

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

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

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

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

Console

  1. No Console do Cloud, acesse a página Criar chave da conta de serviço.

    Acessar página "Criar chave da conta de serviço"

  2. Na lista Conta de serviço, selecione Nova conta de serviço.

  3. No campo Nome da conta de serviço, insira um nome.

  4. Na lista Papel, selecione os seguintes papéis:

    • Pub/Sub: assinante do Pub/Sub
    • Cloud Healthcare: Ingestão de mensagens HL7v2 do Healthcare
  5. Se você quiser ativar o monitoramento, selecione o seguinte papel adicional:

    • Monitoring > Gravador de métricas do Monitoring
  6. Clique em Criar

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
    

    A saída é a conta de serviço:

    Created service account SERVICE_ACCOUNT_NAME.
    
  2. Para conceder cada papel à 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.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
    
  3. Para criar uma chave de conta de serviço, execute o comando gcloud iam service-accounts keys create.

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

    Depois que a conta de serviço é criada, será feito o download de um arquivo de chave JSON contendo as credenciais da conta de serviço para seu computador. Você usará esse arquivo de chave para configurar o adaptador MLLP para autenticação na API Cloud Healthcare, API Pub/Sub e API Cloud Monitoring usando o --service-account sinalização durante criação de cluster.

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

Como criar o cluster

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

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

onde:

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

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

Creating cluster mllp-adapter in COMPUTE_ZONE...
Cluster is being configured...
Cluster is being deployed...
Cluster is being health-checked...
Cluster is being health-checked (master is healthy)...done.
Created [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/COMPUTE_ZONE/clusters/mllp-adapter].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/COMPUTE_ZONE/mllp-adapter?project=PROJECT_ID
kubeconfig entry generated for mllp-adapter.
NAME          LOCATION       MASTER_VERSION  MASTER_IP      MACHINE_TYPE   NODE_VERSION  NUM_NODES  STATUS
mllp-adapter  COMPUTE_ZONE   1.11.7-gke.4    203.0.113.1    n1-standard-1  1.11.7-gke.4  3          RUNNING

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

gcloud compute instances list

Como configurar a implantação

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

  1. Abra um terminal separado.

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

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

onde:

  • PROJECT_ID é o código do projeto do Google Cloud que contém o armazenamento HL7v2.
  • LOCATION é a região em que sua loja HL7v2 está localizada;
  • DATASET_ID é o código do conjunto de dados pai do armazenamento HL7v2.
  • HL7V2_STORE_ID é o código do armazenamento HL7v2 para o qual você está enviando mensagens HL7v2.
  • RECEIVER_IP é o endereço IP da central de atendimento de origem. Se você estiver testando a partir de uma máquina local que esteja agindo como a central de atendimento, defina RECEIVER_IP como 0.0.0.0.

A implantação tem as seguintes propriedades:

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

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

Como configurar o serviço

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

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

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

apiVersion: v1
kind: Service
metadata:
  name: mllp-adapter-service
  annotations:
    cloud.google.com/load-balancer-type: "Internal"
spec:
  type: LoadBalancer
  ports:
  - name: port
    port: 2575
    targetPort: 2575
    protocol: TCP
  selector:
    app: mllp-adapter

O serviço tem as seguintes propriedades:

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

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

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

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

Como implantar a implantação

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

kubectl apply -f mllp_adapter.yaml

O comando retorna a seguinte saída:

deployment.extensions "mllp-adapter-deployment" created

Como inspecionar a implantação

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

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

kubectl describe deployment mllp-adapter

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

kubectl get pods -l app=mllp-adapter

Para receber informações sobre o pod criado:

kubectl describe pod POD_NAME

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

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

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

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

kubectl apply -f mllp_adapter_service.yaml

O comando retorna a seguinte saída:

service "mllp-adapter-service" created

Como inspecionar o serviço

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

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

kubectl describe service mllp-adapter-service

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

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

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

Como criar uma VM do Compute Engine e enviar mensagens

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

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

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

Console

  1. No Console do Cloud, acesse a página Criar chave da conta de serviço.

    Acessar página "Criar chave da conta de serviço"

  2. Na lista Conta de serviço, selecione Nova conta de serviço.

  3. No campo Nome da conta de serviço, insira um nome.

  4. Na lista Papel, selecione os dois papéis a seguir:

    • Pub/Sub: assinante do Pub/Sub
    • Cloud Healthcare: Consumidor de mensagens HL7v2 do Healthcare
  5. Clique em Criar

Depois que a conta de serviço é criada, será feito o download de um arquivo de chave JSON contendo as credenciais da conta de serviço para seu computador.

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
    

    A saída é a conta de serviço:

    Created service account SERVICE_ACCOUNT_NAME.
    
  2. Para conceder cada papel à 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
    
  3. Para criar uma chave de conta de serviço, execute o comando gcloud iam service-accounts keys create.

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

    Depois que a conta de serviço é criada, será feito o download de um arquivo de chave JSON contendo as credenciais da conta de serviço para seu computador.

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

Console

  1. No Console do Cloud, acesse a página Instâncias de VM.

    Acessar a página Instâncias de VM (em inglês)

  2. Clique em Criar instância.

  3. Escolha uma Região e uma Zona para a instância que corresponda à zona selecionada quando você criou o cluster. Por exemplo, se você usou us-central1-a para COMPUTE_ZONE ao criar o cluster, selecione us-central1 (Iowa) para Região e us-central1-a para a Zona.

  4. Na seção Disco de inicialização, clique em Alterar para configurar o disco de inicialização.

  5. Na guia Imagens públicas, escolha a versão 9 do sistema operacional Debian.

  6. Clique em Select.

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

  8. Na seçã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 selecionado quando você criou o cluster
  • A tag http-server para permitir o tráfego HTTP
  • O SERVICE_ACCOUNT que você criou
gcloud compute instances create COMPUTE_NAME \
   --project=PROJECT_ID \
   --zone=ZONE \
   --image-family=debian-9 \
   --image-project=debian-cloud \
   --tags=http-server \
   --service-account=SERVICE_ACCOUNT

A saída é semelhante à seguinte amostra:

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/COMPUTE_NAME].
NAME          ZONE           MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP    STATUS
COMPUTE_NAME  ZONE           n1-standard-1               INTERNAL_IP  EXTERNAL_IP    RUNNING

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

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

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

Console

  1. No Console do Cloud, acesse a página Instâncias de VM.

    Acessar a página Instâncias de VM

  2. Na lista de instâncias de máquina virtual, clique em SSH na linha da instância que você criou.

gcloud

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

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

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

  1. Na janela do terminal, instale o Netcat:

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

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

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

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

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

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

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

    gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION
    

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

    ┌-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┐
    |                                                               DATA                                              |    MESSAGE_ID   |   ATTRIBUTES  |
    ├-----------------------------------------------------------------------------------------------------------------|-----------------|---------------|
    | projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/HL7V2_MESSAGE_ID | 123456789012345 | msgType=ADT   |
    └-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘
    
  5. Você também pode listar as mensagens no seu armazenamento HL7v2 para ver se a mensagem foi adicionada:

    curl

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

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

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

    PowerShell

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

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

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

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

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

Como configurar uma VPN

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

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

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

Como configurar o Cloud VPN

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

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

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

Referência de nomenclatura e endereçamento

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

No lado do Google Cloud

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

Local

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

Como criar redes e sub-redes VPC personalizadas

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

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

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

    gcloud compute networks create cloud-vpn-network \
       --project=PROJECT_ID \
       --subnet-mode=custom
    
  2. Para criar a sub-rede subnet-us-central-10-0-1 para a rede cloud-vpn-network, execute o seguinte comando:

    gcloud compute networks subnets create subnet-us-central-10-0-1 \
       --project=PROJECT_ID \
       --region=us-central1 \
       --network=cloud-vpn-network \
       --range=10.0.1.0/24
    
  3. Para criar a rede VPC on-prem-vpn-network, execute o seguinte comando:

    gcloud compute networks create on-prem-vpn-network \
       --project=PROJECT_ID \
       --subnet-mode=custom
    
  4. Para criar a sub-rede subnet-europe-west-10-0-2 para a rede VPC on-prem-vpn-network, execute o seguinte comando:

    gcloud compute networks subnets create subnet-europe-west-10-0-2 \
       --project=PROJECT_ID \
       --region=europe-west1 \
       --network=on-prem-vpn-network \
       --range=10.0.2.0/24
    

Como criar um endereço IP externo

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

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

    gcloud compute addresses create cloud-vpn-ip \
       --project=PROJECT_ID \
       --region=us-central1
    
  2. Para reservar um endereço IP externo estático (regional) para o endereço on-prem-vpn-ip, execute o seguinte comando:

    gcloud compute addresses create on-prem-vpn-ip \
       --project=PROJECT_ID \
       --region=europe-west1
    
  3. Anote os endereços IP externos para que você possa usá-los para configurar os gateways da VPN na próxima seção. Para recuperar os endereços IP externos, execute o seguinte comando:

    Endereço IP do Cloud VPN:

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

    Endereço IP da VPN "local":

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

    Os comandos retornam uma saída semelhante a esta:

    address: 203.0.113.1
    

Como criar gateways, túneis e rotas de VPN

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

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

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

    gcloud compute target-vpn-gateways create vpn-us-central \
       --project PROJECT_ID \
       --region us-central1 \
       --network cloud-vpn-network
    
  3. Para criar três regras de encaminhamento, execute os seguintes comandos, substituindo a variável CLOUD_VPN_EXTERNAL_ADDRESS pelo valor do endereço IP do Cloud VPN na seção anterior:

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

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

    Envie o tráfego UDP 500 para o gateway:

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

    Envie o tráfego UDP 4500 para o gateway:

    gcloud compute forwarding-rules create vpn-us-central-rule-udp4500 \
        --project PROJECT_ID \
        --region us-central1 \
        --address CLOUD_VPN_EXTERNAL_ADDRESS \
        --ip-protocol UDP \
        --ports 4500 \
        --target-vpn-gateway vpn-us-central
    
  4. Para criar um túnel no gateway do Cloud VPN, execute o comando a seguir. Substitua ON_PREM_VPN_IP pelo valor do endereço IP da VPN"local" na seção anterior.

    gcloud compute vpn-tunnels create vpn-us-central-tunnel-1 \
        --project PROJECT_ID \
        --region us-central1 \
        --peer-address ON_PREM_VPN_IP \
        --shared-secret SHARED_SECRET \
        --ike-version 2 \
        --local-traffic-selector 0.0.0.0/0 \
        --target-vpn-gateway vpn-us-central
    
  5. Para criar uma rota estática para 10.0.2.0/24, execute o seguinte comando:

    gcloud compute routes create "vpn-us-central-tunnel-1-route-1" \
       --project PROJECT_ID \
       --network "cloud-vpn-network" \
       --next-hop-vpn-tunnel "vpn-us-central-tunnel-1" \
       --next-hop-vpn-tunnel-region "us-central1" \
       --destination-range "10.0.2.0/24"
    

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

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

    gcloud compute target-vpn-gateways create "vpn-europe-west" \
       --project PROJECT_ID \
       --region "europe-west1" \
       --network "on-prem-vpn-network"
    
  2. Para criar três regras de encaminhamento, execute os seguintes comandos, substituindo a variável ON_PREMISES_VPN_EXTERNAL_ADDRESS pelo valor do endereço IP da VPN"local" na seção anterior:

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

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

    Envie o tráfego UDP 500 para o gateway:

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

    Envie o tráfego UDP 4500 para o gateway:

    gcloud compute forwarding-rules create vpn-europe-west-rule-udp4500 \
         --project PROJECT_ID \
         --region europe-west1 \
         --address ON_PREMISES_VPN_EXTERNAL_ADDRESS \
         --ip-protocol UDP \
         --ports 4500 \
         --target-vpn-gateway vpn-europe-west
    
  3. Para criar um túnel no gateway "local", execute o seguinte comando:

    gcloud compute vpn-tunnels create vpn-europe-west-tunnel-1 \
       --project PROJECT_ID \
       --region europe-west1 \
       --peer-address CLOUD_VPN_IP \
       --shared-secret SHARED_SECRET \
       --ike-version 2 \
       --local-traffic-selector 0.0.0.0/0 \
       --target-vpn-gateway vpn-europe-west
    
  4. Para criar uma rota estática para 10.0.1.0/24, execute o seguinte comando:

    gcloud compute routes create "vpn-europe-west-tunnel-1-route-1" \
       --project PROJECT_ID \
       --network "on-prem-vpn-network" \
       --next-hop-vpn-tunnel "vpn-europe-west-tunnel-1" \
       --next-hop-vpn-tunnel-region "europe-west1" \
       --destination-range "10.0.1.0/24"
    

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

Criar regras de firewall

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

  1. Para criar as regras de firewall para a sub-rede do Cloud VPN, execute o seguinte comando:

    gcloud compute firewall-rules create allow-tcp-udp-icmp-cloud-vpn \
       --project=PROJECT_ID \
       --direction=INGRESS \
       --priority=1000 \
       --network=cloud-vpn-network \
       --action=ALLOW \
       --rules=tcp,udp,icmp \
       --source-ranges=10.0.2.0/24
    
  2. Para criar as regras de firewall para a sub-rede "local", execute o seguinte comando:

    gcloud compute firewall-rules create allow-tcp-udp-icmp-on-prem-vpn \
       --project=PROJECT_ID \
       --direction=INGRESS \
       --priority=1000 \
       --network=on-prem-vpn-network \
       --action=ALLOW \
       --rules=tcp,udp,icmp \
       --source-ranges=10.0.1.0/24
    
  3. Crie uma regra de firewall que permita o SSH na instância de VM na porta 22 executando o seguinte comando:

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

Como verificar o status do túnel VPN

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

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

    Acesse a página VPN

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

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

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

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

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

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

Como recriar a implantação

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

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

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

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

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

    onde:

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

    • CLIENT_EMAIL é o identificador da conta de serviço. Você pode encontrá-lo no arquivo de chave da conta de serviço no campo "client_email":. Ele usa o formato SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com.

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

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

Console

  1. No Console do Cloud, acesse a página Instâncias de VM.

    Acessar a página Instâncias de VM (em inglês)

  2. Clique em Criar instância.

  3. Escolha um Região e Zona a instância que corresponde ao "" local " configurações de rede: europe-west1 (Belgium) O Google Maps Engine Região e europe-west1-b O Google Maps Engine Zona.

  4. Na seção Boot disk, clique em Change para iniciar a configuração do disco de inicialização.

  5. Na guia Imagens públicas, escolha a versão 9 do sistema operacional Debian.

  6. Clique em Select.

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

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

  9. Expanda a seção Gerenciamento, segurança, discos, rede, locatário único.

  10. Em Interfaces de rede na guia Rede, especifique os detalhes da rede para as configurações de rede "no local":

    1. No campo Rede, selecione on-prem-vpn-network.
    2. Na seção Sub-rede campo, selecione subnet-europe-west-10-0-2 (10.0.2.0/24).
  11. Clique em Criar para criar a instância.

Aguarde a inicialização da instância. Quando estiver pronto, ele será listado na página "Instâncias de VMs" com um ícone de status 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 configurações de rede "no local": europe-west1-b para a Zona.
  • Permitir tráfego HTTP especificando a tag http-server
  • O SERVICE_ACCOUNT que você criou
gcloud compute instances create COMPUTE_NAME \
   --project=PROJECT_ID
   --zone=ZONE
   --image-family=debian-9 \
   --tags=http-server,https-server
   --service-account=SERVICE_ACCOUNT

A saída é semelhante à seguinte amostra:

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/COMPUTE_NAME].
NAME          ZONE           MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP    STATUS
COMPUTE_NAME  ZONE           n1-standard-1               INTERNAL_IP  EXTERNAL_IP    RUNNING

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

Console

  1. No Console do Cloud, acesse a página Instâncias de VM.

    Acessar a página Instâncias de VM

  2. Na lista de instâncias de máquina virtual, clique em SSH na linha da instância que você criou.

gcloud

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

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

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

  1. Na janela do terminal, instale o Netcat:

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

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

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

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

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

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

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

    gcloud pubsub subscriptions pull --auto-ack PUBSUB_SUBSCRIPTION
    

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

    ┌-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┐
    |                                                               DATA                                              |    MESSAGE_ID   |   ATTRIBUTES  |
    ├-----------------------------------------------------------------------------------------------------------------|-----------------|---------------|
    | projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/HL7V2_MESSAGE_ID | 123456789012345 | msgType=ADT   |
    └-----------------------------------------------------------------------------------------------------------------|-----------------|---------------┘
    
  5. Você também pode listar as mensagens no seu armazenamento HL7v2 para ver se a mensagem foi adicionada:

    curl

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

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

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

    PowerShell

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

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

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

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

Limpar

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

Exclua o projeto

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

  1. No Console do Cloud, acesse a página Gerenciar recursos:

    Acessar a página "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Resolver problemas

Falhas no adaptador

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

Erro Connection refused ao executar localmente

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

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

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

Erro could not find default credentials ao executar localmente

Ao testar o adaptador MLLP localmente, você encontra o erro healthapiclient.NewHL7V2Client: oauth2google.DefaultTokenSource: google: could not find default credentials. See https://developers.google.com/accounts/docs/application-default-credentials for more information..

Esse erro ocorre quando o adaptador não consegue encontrar suas credenciais do Google Cloud. Para corrigir o erro, tente um dos seguintes métodos antes de executar o comando novamente: