Esta página foi traduzida pela API Cloud Translation.

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 documento, você usará os seguintes componentes faturáveis do Google Cloud:

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

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

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 Google Cloud CLI e a ferramenta de linha de comando kubectl. A CLI gcloud fornece a interface de linha de comando principal do Google Cloud. A ferramenta kubectl fornece a interface de linha de comando para executar comandos em clusters do Kubernetes.

Se você preferir usar o shell local, instale a Google Cloud CLI.

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

Cloud Shell

Para iniciar o Cloud Shell, siga estas etapas:

Acesse o Console do Google Cloud.

Console do Google Cloud
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 CLI gcloud e a ferramenta kubectl, conclua as etapas a seguir:

Instale e inicialize a CLI gcloud.
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:

Crie o projeto do Cloud KMS concluindo as seguintes etapas:
1. No console do Google Cloud, acesse a página "Novo projeto".
  Acesse o novo projeto
2. Preencha o formulário e clique em Criar. O nome do projeto selecionado é referenciado como KMS_PROJ_ID neste tutorial.
Para mais informações sobre como criar projetos, consulte Como criar e gerenciar projetos.
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
```
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
```

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"

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:

Para criar o projeto HL7v2, siga estas etapas:
1. No console do Google Cloud, acesse a página "Novo projeto".
  Acesse o novo projeto
2. Preencha o formulário e clique em Criar. O nome do projeto selecionado é referenciado como HL7V2_PROJ_ID neste tutorial.

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

gcloud services enable healthcare.googleapis.com \
    --project=HL7V2_PROJ_ID

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

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 Artifact Analysis

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

Para criar uma nota do Artifact Analysis, conclua as seguintes etapas:

Crie o projeto de nota concluindo as seguintes etapas:
1. No console do Google Cloud, acesse a página "Novo projeto".
  Acesse o 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.

Para ativar a API Artifact Analysis no projeto de nota, execute o seguinte comando:

gcloud services enable containeranalysis.googleapis.com \
     --project=NOTE_PROJ_ID

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

Para criar uma nota do Artifact 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"

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:

Para criar o projeto de atestador, siga estas etapas:
1. No console do Google Cloud, acesse a página "Novo projeto".
  Acesse o 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.

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

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

Para verificar se o atestador foi criado, execute o seguinte comando:

gcloud beta container binauthz attestors list \
    --project=ATTESTOR_PROJ_ID

Faça as seguintes substituições e salve o JSON de amostra em um arquivo chamado ./tmp/iam_request.json executando o seguinte comando:
- Use os valores de NOTE_PROJ_ID e NOTE_ID de Como criar uma nota do Artifact Analysis.
- Para encontrar o ATTESTOR_PROJECT_NUM, siga estas etapas:
  1. Acesse a página Painel no console do Google Cloud:
    Ir para a página "Painel"
  2. Clique na lista suspensa Selecionar de na parte superior da página. Na janela Selecionar de exibida, selecione o projeto do atestador.
  O número do projeto é exibido no cartão Informações do projeto.
```
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
```

Para conceder permissão à conta de serviço de autorização binária do projeto do atestador para ler as ocorrências de nota do Artifact 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"

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:

Para criar o projeto de atestado, siga estas etapas:
1. No console do Google Cloud, acesse a página "Novo projeto".
  Acesse o 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.

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

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:

Para criar o projeto do implantador, siga estas etapas:
1. No console do Google Cloud, acesse a página "Novo projeto".
  Acesse o 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.
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
```

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

Para criar um cluster com --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE no projeto do implantador, execute o seguinte comando:

gcloud beta container clusters create CLUSTER_NAME \
    --project=DEPLOYER_PROJ_ID \
    --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE \
    --zone CLUSTER_ZONE

A política de implantação de amostra adiciona origens de imagem à lista de permissões e define uma regra padrão do 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

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
```
Para visualizar detalhes sobre a política, acesse a página da autorização binária no console do Google Cloud.

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

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

Faça as seguintes substituições e salve o YAML de amostra em um arquivo chamado ./tmp/deployment.yaml executando o seguinte comando:

IMAGE_SIGNED é o local da imagem do adaptador MLLP assinado, gcr.io/cloud-healthcare-containers/mllp-adapter@sha256:231b073df13db0c65e57b0e1d526ab6816a73c37262e25c18bcca99bf4b4b185.
Use os valores de HL7V2_PROJ_ID, HL7V2_STORE_LOCATION, DATASET_ID e HL7V2_STORE_ID usados em Como criar e configurar o projeto, conjunto de dados e armazenamento HL7v2.

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

Para criar uma implantação com a imagem atestada, execute o seguinte comando:
```
kubectl create -f ./tmp/deployment.yaml
```
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

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

No Console do Google Cloud, acesse a página Gerenciar recursos.
Acessar "Gerenciar recursos"
Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.