Como transmitir mensagens HL7v2 por conexões TCP/IP usando uma imagem MLLP assinada

Neste tutorial, fornecemos instruções para usar a autorização binária como parte de uma implantação mínima do protocolo de camada inferior (MLLP, na sigla em inglês) em uma configuração de vários projetos. O uso da autorização binária no Google Kubernetes Engine garante que o adaptador MLLP só possa ser implantado a partir de uma imagem de contêiner verificada e assinada.

O codelab da autorização binária do adaptador MLLP de código aberto no GitHub demonstra um cenário semelhante em detalhes.

Objetivos

Depois de concluir este tutorial, você saberá:

  • Configure um atestador para atestar quando uma imagem MLLP estiver pronta para implantação.
  • Implantar uma imagem atestada do binário do adaptador MLLP.
  • Usar uma configuração de vários projetos para separar a responsabilidade para a assinatura de imagens a partir do ambiente de implantação.

Custos

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

  • API Cloud Healthcare
  • Google Kubernetes Engine
  • Container Analysis
  • Cloud Key Management Service
  • Autorização binária

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.

Pré-requisitos

Antes de começar este tutorial, familiarize-se com a documentação conceitual sobre o MLLP 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.

Como escolher um shell

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

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

Se você preferir usar o shell local, instale o SDK do Cloud, que inclui as ferramentas gcloud e 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 será 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. Execute o seguinte comando para instalar a ferramenta de linha de comando kubectl:

    gcloud components install kubectl
    

Projeto de contêiner

O projeto de contêiner, cloud-healthcare-containers, já existe. Ele contém as imagens do adaptador MLLP.

Como criar um keyring e um par de chaves

O projeto do Cloud KMS fornece uma assinatura de infraestrutura de chave pública (X.509) (PKIX) usando o Cloud KMS. A autorização binária usa chaves criptográficas para verificar com segurança a identidade dos atestadores. Isso garante que apenas as partes verificadas possam participar da autorização de uma imagem de contêiner. O par de chaves consiste em uma chave privada, que o atestador usa para assinar atestados digitalmente, e uma chave pública, que você adiciona ao atestador conforme armazenado pelo serviço de autorização binária.

Se você quiser gerenciar pares de chaves privadas e públicas localmente, o projeto do Cloud KMS não será necessário. Para mais informações, consulte Como usar chaves de criptografia gerenciadas pelo cliente.

Para criar um keyring e um par de chaves, siga estas etapas:

  1. Crie o projeto do Cloud KMS concluindo as seguintes etapas:

    1. No Console do Cloud, acesse a página "Novo projeto".

      Acessar a página "Novo projeto"

    2. Preencha o formulário e clique em Criar. O nome do projeto selecionado é referenciado como KMS_PROJ_ID ao longo deste tutorial.

    Para mais informações sobre como criar projetos, consulte Como criar e gerenciar projetos.

  2. Para ativar a API Cloud KMS no projeto do Cloud KMS, execute o seguinte comando:

    gcloud services enable cloudkms.googleapis.com \
        --project=KMS_PROJ_ID
    
  3. Para criar um keyring, execute o seguinte comando, em que KEY_RING é um nome exclusivo para o keyring e KEY_RING_LOCATION é uma região como us-central-1:

    gcloud kms keyrings create KEY_RING \
        --project=KMS_PROJ_ID \
        --location=KEY_RING_LOCATION
    
  4. Para criar um par de chaves, execute o seguinte comando:

    gcloud kms keys create KEY \
        --project=KMS_PROJ_ID \
        --keyring=KEY_RING \
        --location=KEY_RING_LOCATION \
        --purpose=asymmetric-signing \
        --default-algorithm="ec-sign-p256-sha256"
    
  5. Para verificar a versão da chave no projeto do Cloud KMS, execute o comando a seguir. A versão da chave precisa ser 1.

    gcloud kms keys versions list \
        --project=KMS_PROJ_ID \
        --location=KEY_RING_LOCATION \
        --key=KEY \
        --keyring=KEY_RING
    

Como criar e configurar o projeto, o conjunto de dados e o armazenamento HL7v2 do HL7v2

Para criar e configurar o projeto HL7v2, o conjunto de dados e o armazenamento HL7v2, conclua as seguintes etapas:

  1. Para criar o projeto HL7v2, siga estas etapas:

    1. No Console do Cloud, acesse a página "Novo projeto".

      Acessar a página "Novo projeto"

    2. Preencha o formulário e clique em Criar. O nome do projeto selecionado é referenciado como HL7V2_PROJ_ID neste tutorial.

  2. Para ativar a API Cloud Healthcare no projeto, execute o seguinte comando:

    gcloud services enable healthcare.googleapis.com \
        --project=HL7V2_PROJ_ID
    
  3. Para criar um conjunto de dados para armazenar o armazenamento HL7v2, execute o seguinte comando:

    gcloud healthcare datasets create DATASET_ID \
        --location=HL7V2_STORE_LOCATION \
        --project=HL7V2_PROJ_ID
    
  4. Para criar o armazenamento HL7v2, execute o seguinte comando:

    gcloud healthcare hl7v2-stores create HL7V2_STORE_ID \
        --dataset=DATASET_ID \
        --location=HL7V2_STORE_LOCATION \
        --project=HL7V2_PROJ_ID
    

Como criar uma nota do Container Analysis

O projeto de nota é proprietário da nota do Container Analysis.

Para criar uma nota do Container Analysis, siga estas etapas:

  1. Crie o projeto de nota concluindo as seguintes etapas:

    1. No Console do Cloud, acesse a página "Novo projeto".

      Acessar a página "Novo projeto"

    2. Preencha o formulário e clique em Criar. O nome do projeto selecionado é referenciado como NOTE_PROJ_ID ao longo deste tutorial.
  2. Para ativar a Container Analysis API no projeto de nota, execute o seguinte comando:

    gcloud services enable containeranalysis.googleapis.com \
         --project=NOTE_PROJ_ID
    
  3. Para salvar o payload da nota de amostra em um arquivo chamado ./tmp/note_payload.json, execute o seguinte comando:

    cat > ./tmp/note_payload.json << EOM
    {
      "name": "projects/NOTE_PROJ_ID/notes/NOTE_ID",
      "attestation": {
        "hint": {
          "human_readable_name": "Attestor note"
        }
      }
    }
    EOM
    
  4. Para criar uma nota do Container Analysis no projeto de nota, execute o seguinte comando:

    curl -X POST \
        -H "Content-Type: application/json" \
        -H "Authorization: Bearer $(gcloud auth application-default print-access-token)"  \
        --data-binary @./tmp/note_payload.json  \
        "https://containeranalysis.googleapis.com/v1/projects/NOTE_PROJ_ID/notes/?noteId=NOTE_ID"
    
  5. Para verificar se a nota foi criada, execute o seguinte comando:

    curl \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    "https://containeranalysis.googleapis.com/v1/projects/NOTE_PROJ_ID/notes/NOTE_ID"
    

Como criar e configurar um atestador

O projeto do atestador armazena atestadores, que verificam ou atestam que uma imagem de contêiner está pronta para implantação.

Para criar e configurar um atestador, siga estas etapas:

  1. Para criar o projeto de atestador, siga estas etapas:

    1. No Console do Cloud, acesse a página "Novo projeto".

      Acessar a página "Novo projeto"

    2. Preencha o formulário e clique em Criar. O nome do projeto selecionado é referenciado como ATTESTOR_PROJ_ID ao longo deste tutorial.
  2. Para ativar as APIs de autorização binária e do Cloud KMS no projeto do atestador, execute os seguintes comandos:

    gcloud services enable binaryauthorization.googleapis.com \
        --project=ATTESTOR_PROJ_ID
    gcloud services enable cloudkms.googleapis.com \
        --project=ATTESTOR_PROJ_ID
    
  3. Para criar um atestador no projeto do atestador, execute o comando a seguir. O atestador usa a nota criada no projeto de nota para atestar.

    gcloud beta container binauthz attestors create ATTESTOR_ID \
        --project=ATTESTOR_PROJ_ID \
        --attestation-authority-note=NOTE_ID \
        --attestation-authority-note-project=NOTE_PROJ_ID
    
  4. Para verificar se o atestador foi criado, execute o seguinte comando:

    gcloud beta container binauthz attestors list \
        --project=ATTESTOR_PROJ_ID
    
  5. Faça as seguintes substituições e salve o JSON de amostra em um arquivo chamado ./tmp/iam_request.json executando o seguinte comando:

    cat > ./tmp/iam_request.json << EOM
    {
      "resource": "projects/NOTE_PROJ_ID/notes/NOTE_ID",
      "policy": {
        "bindings": [
          {
            "role": "roles/containeranalysis.notes.occurrences.viewer",
            "members": [
              "serviceAccount:service-ATTESTOR_PROJ_NUM@gcp-sa-binaryauthorization.iam.gserviceaccount.com"
            ]
          }
        ]
      }
    }
    EOM
    
  6. Para conceder permissão à conta de serviço de autorização binária do projeto atestador para ler as ocorrências de nota do Container Analysis no projeto de nota, execute o seguinte comando:

    curl -X POST  \
        -H "Content-Type: application/json" \
        -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
        --data-binary @./tmp/iam_request.json \
    "https://containeranalysis.googleapis.com/v1/projects/NOTE_PROJ_ID/notes/NOTE_ID:setIamPolicy"
    
  7. Para adicionar a chave gerada no projeto do Cloud KMS ao atestador, execute o seguinte comando:

    gcloud beta container binauthz attestors public-keys add  \
        --project=ATTESTOR_PROJ_ID \
        --attestor=ATTESTOR_ID  \
        --keyversion-project=KMS_PROJ_ID  \
        --keyversion-location=KEY_RING_LOCATION \
        --keyversion-keyring=KEY_RING \
        --keyversion-key=KEY \
        --keyversion=KEY_VERSION
    

Como criar um atestado

O projeto de atestado armazena atestados. Um atestado é uma declaração de um atestador de que um processo obrigatório no pipeline foi concluído e uma imagem de contêiner está autorizada para implantação.

Para criar um atestado, siga estas etapas:

  1. Para criar o projeto de atestado, siga estas etapas:

    1. No Console do Cloud, acesse a página "Novo projeto".

      Acessar a página "Novo projeto"

    2. Preencha o formulário e clique em Criar. O nome do projeto selecionado é referenciado como ATTESTATION_PROJ_ID ao longo deste tutorial.
  2. Para ativar a API de autorização binária no projeto de atestado, execute o seguinte comando:

    gcloud services enable binaryauthorization.googleapis.com \
        --project=ATTESTATION_PROJ_ID
    
  3. Para assinar e criar o atestado, execute o seguinte comando, em que IMAGE_SIGNED é o local da imagem do adaptador MLLP assinado, gcr.io/cloud-healthcare-containers/mllp-adapter@sha256:231b073df13db0c65e57b0e1d526ab6816a73c37262e25c18bcca99bf4b4b185:

    gcloud beta container binauthz attestations sign-and-create \
        --project=ATTESTATION_PROJ_ID \
        --artifact-url=IMAGE_SIGNED \
        --attestor=ATTESTOR_ID \
        --attestor-project=ATTESTOR_PROJ_ID \
        --keyversion-project=KMS_PROJ_ID \
        --keyversion-location=KEY_RING_LOCATION \
        --keyversion-keyring=KEY_RING \
        --keyversion-key=KEY \
        --keyversion=KEY_VERSION
    

Como implantar o adaptador MLLP

O projeto do implantador é proprietário do cluster do GKE em que a autorização binária é importada e armazenada.

Para implantar o adaptador MLLP, siga estas etapas:

  1. Para criar o projeto do implantador, siga estas etapas:

    1. No Console do Cloud, acesse a página "Novo projeto".

      Acessar a página "Novo projeto"

    2. Preencha o formulário e clique em Criar. O nome do projeto selecionado é referenciado como DEPLOYER_PROJ_ID ao longo deste tutorial.
  2. Para ativar a API de autorização binária no projeto do implantador, execute o seguinte comando:

    gcloud services enable binaryauthorization.googleapis.com \
        --project=DEPLOYER_PROJ_ID
    
  3. Para conceder à conta de serviço de autorização binária no projeto do implantador permissão para acessar o atestador para verificação de atestado, execute o seguinte comando:

    gcloud beta container binauthz attestors add-iam-policy-binding \
        "projects/ATTESTOR_PROJ_ID/attestors/ATTESTOR_ID" \
        --project=ATTESTOR_PROJ_ID \
        --member="serviceAccount:service-DEPLOYER_PROJ_NUM@gcp-sa-binaryauthorization.iam.gserviceaccount.com" \
        --role=roles/binaryauthorization.attestorsVerifier
    
  4. Para criar um cluster com --enable-binauthz no projeto do implantador, execute o seguinte comando:

    gcloud beta container clusters create CLUSTER_NAME \
        --project=DEPLOYER_PROJ_ID \
        --enable-binauthz \
        --zone CLUSTER_ZONE
    
  5. A política de implantação de amostra adiciona origens de imagem à lista de permissões e define uma regra padrão de escopo do projeto para bloquear imagens de origens que não foram atestadas pelo atestador. Para salvar a política de implantação de amostra em um arquivo chamado ./tmp/policy.yaml, execute o seguinte comando:

    cat > ./tmp/policy.yaml << EOM
        admissionWhitelistPatterns:
        - namePattern: gcr.io/google_containers/*
        - namePattern: gcr.io/google-containers/*
        - namePattern: k8s.gcr.io/*
        - namePattern: gcr.io/stackdriver-agents/*
        defaultAdmissionRule:
          evaluationMode: REQUIRE_ATTESTATION
          enforcementMode: ENFORCED_BLOCK_AND_AUDIT_LOG
          requireAttestationsBy:
            - projects/ATTESTOR_PROJ_ID/attestors/ATTESTOR_ID
        name: projects/DEPLOYER_PROJ_ID/policy
    EOM
    
  6. Para importar a política de implantação para o projeto do implantador, execute o seguinte comando:

    gcloud beta container binauthz policy import ./tmp/policy.yaml \
        --project=DEPLOYER_PROJ_ID
    
  7. Para ver detalhes sobre a política, acesse a página "Autorização binária" no Console do Google Cloud.

    Acessar a página "Autorização binária"

  8. Para verificar as credenciais do cluster do GKE, execute o seguinte comando:

    gcloud container clusters get-credentials \
        --project=DEPLOYER_PROJ_ID \
        --zone CLUSTER_ZONE CLUSTER_NAME
    
  9. Faça as seguintes substituições e salve o YAML de amostra em um arquivo chamado ./tmp/deployment.yaml executando o seguinte comando:

    cat > ./tmp/deployment.yaml << EOM
     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: IMAGE_SIGNED
               ports:
                 - containerPort: 2575
                   protocol: TCP
                   name: "port"
               command:
                 - "/usr/mllp_adapter/mllp_adapter"
                 - "--hl7_v2_project_id=HL7V2_PROJ_ID"
                 - "--hl7_v2_location_id=HL7V2_STORE_LOCATION"
                 - "--hl7_v2_dataset_id=DATASET_ID"
                 - "--hl7_v2_store_id=HL7V2_STORE_ID"
                 - "--api_addr_prefix=https://healthcare.googleapis.com:443/v1beta1"
                 - "--logtostderr"
                 - "--receiver_ip=0.0.0.0"
    EOM
    
  10. Para criar uma implantação com a imagem atestada, execute o seguinte comando:

    kubectl create -f ./tmp/deployment.yaml
    
  11. Para confirmar se a implantação foi bem-sucedida, execute os seguintes comandos:

    kubectl get pods
    kubectl get event
    

    O comando get pods mostra um pod em execução, e o get event mostra Scaled up replica set mllp-adapter-deployment-xxxx to 1.

Ao concluir esta seção, você terá implantado com segurança uma imagem de adaptador MLLP atestada no Google Kubernetes Engine.

Como excluir os projetos

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

Siga as etapas abaixo para excluir os seguintes projetos criados neste tutorial:

  • Projeto de atestador
  • Projeto de atestado
  • Projeto de implantação
  • Projeto de nota
  • Projeto do Cloud KMS
  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.